@factucat/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1023 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import { mkdir, stat, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import { confirm, intro, isCancel, outro, select, spinner, text } from '@clack/prompts';
+import { cac } from 'cac';
+import { readConfig, writeConfig } from './lib/config';
+import { getCurrentDraftId, setCurrentDraftId } from './lib/current-draft';
+import { exitCodeFromError, getErrorMessage } from './lib/errors';
+import { printHuman, printJson } from './lib/output';
+import { getSdk } from './lib/sdk';
+const HELP_TEXT = `factucat
+
+Uso:
+  factucat <comando> [opciones]
+
+Comandos:
+  auth api-key set
+  auth api-key show
+  auth api-key clear
+  auth status
+  invoice create
+  invoice use <draftId>
+  invoice current
+  invoice show
+  invoice list
+  invoice set-customer
+  invoice set-receiver
+  invoice set-meta
+  invoice add-item
+  invoice update-item <itemId>
+  invoice remove-item <itemId>
+  invoice items
+  invoice discard
+  invoice stamp
+  invoice get <invoiceRef>
+  invoice download xml <invoiceRef>
+  invoice download pdf <invoiceRef>
+  customer list
+  customer search <query>
+  customer create
+
+Notas:
+  invoice add-item infiere automáticamente Clave SAT, unidad, IVA e ISR si no los especificas.
+  invoice set-meta --currency USD consulta automáticamente el tipo de cambio oficial del DOF si no mandas --exchange-rate.
+  invoice stamp muestra una previa antes de timbrar cuando hay terminal interactiva.
+  invoice stamp --send-to-customer-contacts solicita el envío por email y WhatsApp registrados en el cliente, si existen.
+`;
+function withJsonFlag(command) {
+    return command.option('--json', 'Imprime salida JSON estable');
+}
+function ensureDraftId(value) {
+    if (!value) {
+        throw new Error('No hay borrador activo. Usa `factucat invoice create` o `factucat invoice use <draft-id>`.');
+    }
+    return value;
+}
+async function resolveDraftId(explicit) {
+    if (explicit) {
+        return explicit;
+    }
+    return ensureDraftId(await getCurrentDraftId());
+}
+async function readStdinValue() {
+    if (process.stdin.isTTY) {
+        return undefined;
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const value = Buffer.concat(chunks).toString('utf8').trim();
+    return value.length > 0 ? value : undefined;
+}
+function normalizeArgv(rawArgv) {
+    const argv = rawArgv[2] === '--'
+        ? [rawArgv[0], rawArgv[1], ...rawArgv.slice(3)]
+        : rawArgv;
+    const args = argv.slice(2);
+    if (args.length === 0) {
+        return { argv, showHelp: true };
+    }
+    if (args.length === 1 && ['--help', '-h', 'help'].includes(args[0] ?? '')) {
+        return { argv, showHelp: true };
+    }
+    const rewrites = [
+        { from: ['auth', 'api-key', 'set'], to: 'auth-api-key-set' },
+        { from: ['auth', 'api-key', 'show'], to: 'auth-api-key-show' },
+        { from: ['auth', 'api-key', 'clear'], to: 'auth-api-key-clear' },
+        { from: ['auth', 'status'], to: 'auth-status' },
+        { from: ['invoice', 'create'], to: 'invoice-create' },
+        { from: ['invoice', 'use'], to: 'invoice-use' },
+        { from: ['invoice', 'current'], to: 'invoice-current' },
+        { from: ['invoice', 'show'], to: 'invoice-show' },
+        { from: ['invoice', 'list'], to: 'invoice-list' },
+        { from: ['invoice', 'set-customer'], to: 'invoice-set-customer' },
+        { from: ['invoice', 'set-receiver'], to: 'invoice-set-receiver' },
+        { from: ['invoice', 'set-meta'], to: 'invoice-set-meta' },
+        { from: ['invoice', 'add-item'], to: 'invoice-add-item' },
+        { from: ['invoice', 'update-item'], to: 'invoice-update-item' },
+        { from: ['invoice', 'remove-item'], to: 'invoice-remove-item' },
+        { from: ['invoice', 'items'], to: 'invoice-items' },
+        { from: ['invoice', 'summary'], to: 'invoice-show' },
+        { from: ['invoice', 'discard'], to: 'invoice-discard' },
+        { from: ['invoice', 'stamp'], to: 'invoice-stamp' },
+        { from: ['invoice', 'get'], to: 'invoice-get' },
+        { from: ['invoice', 'download', 'xml'], to: 'invoice-download-xml' },
+        { from: ['invoice', 'download', 'pdf'], to: 'invoice-download-pdf' },
+        { from: ['customer', 'list'], to: 'customer-list' },
+        { from: ['customer', 'search'], to: 'customer-search' },
+        { from: ['customer', 'create'], to: 'customer-create' },
+    ];
+    for (const rewrite of rewrites) {
+        const matches = rewrite.from.every((part, index) => args[index] === part);
+        if (!matches) {
+            continue;
+        }
+        return {
+            argv: [argv[0] ?? process.argv[0], argv[1] ?? process.argv[1], rewrite.to, ...args.slice(rewrite.from.length)],
+            showHelp: false,
+        };
+    }
+    return { argv, showHelp: false };
+}
+function wantsJson(argv) {
+    return argv.includes('--json');
+}
+function canPromptInteractively(options) {
+    return !options.json && !options.noInput && process.stdin.isTTY && process.stdout.isTTY;
+}
+async function resolveDownloadPath(input) {
+    if (!input.output?.trim()) {
+        return resolve(process.cwd(), input.fileName);
+    }
+    const requestedPath = resolve(process.cwd(), input.output);
+    try {
+        const stats = await stat(requestedPath);
+        if (stats.isDirectory()) {
+            return resolve(requestedPath, input.fileName);
+        }
+        return requestedPath;
+    }
+    catch {
+        if (input.output.endsWith('/') || input.output.endsWith('\\')) {
+            return resolve(requestedPath, input.fileName);
+        }
+        return requestedPath;
+    }
+}
+async function saveDownloadedArtifact(input) {
+    const outputPath = await resolveDownloadPath({
+        fileName: input.fileName,
+        output: input.output,
+    });
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, Buffer.from(input.base64, 'base64'));
+    return outputPath;
+}
+function isUuidLike(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value.trim());
+}
+async function resolveInvoiceReference(input) {
+    const normalizedRef = input.invoiceRef.trim();
+    if (!normalizedRef) {
+        throw new Error('Debes indicar un folio o invoiceId válido.');
+    }
+    if (isUuidLike(normalizedRef)) {
+        return normalizedRef;
+    }
+    const invoices = await input.sdk.listInvoices({
+        query: normalizedRef,
+        limit: 20,
+    });
+    const exactMatches = invoices.filter((invoice) => {
+        const target = normalizedRef.toLowerCase();
+        return (invoice.id.trim().toLowerCase() === target ||
+            invoice.folio.trim().toLowerCase() === target);
+    });
+    if (exactMatches.length === 1) {
+        return exactMatches[0].id;
+    }
+    if (exactMatches.length > 1) {
+        throw new Error(`Hay varias facturas con el folio \`${normalizedRef}\`. Usa el UUID de la factura para desambiguar.`);
+    }
+    throw new Error(`No encontré una factura con el folio o invoiceId \`${normalizedRef}\`.`);
+}
+async function resolveCustomerReference(input) {
+    const normalizedRef = input.customerRef.trim();
+    if (!normalizedRef) {
+        throw new Error('Debes indicar un cliente válido.');
+    }
+    if (isUuidLike(normalizedRef)) {
+        return input.sdk.getCustomer(normalizedRef);
+    }
+    const customers = await input.sdk.listCustomers({
+        query: normalizedRef,
+        limit: 20,
+    });
+    const normalizedNeedle = normalizedRef.toLowerCase();
+    const exactMatches = customers.filter((customer) => {
+        return (customer.id.trim().toLowerCase() === normalizedNeedle ||
+            customer.legalName.trim().toLowerCase() === normalizedNeedle ||
+            customer.rfc.trim().toLowerCase() === normalizedNeedle);
+    });
+    if (exactMatches.length === 1) {
+        return exactMatches[0];
+    }
+    if (exactMatches.length > 1) {
+        throw new Error(`Hay varios clientes que coinciden exactamente con \`${normalizedRef}\`. Usa \`--customer-id\` para elegir uno.`);
+    }
+    if (customers.length === 1) {
+        return customers[0];
+    }
+    if (customers.length === 0) {
+        throw new Error(`No encontré un cliente con \`${normalizedRef}\`. Usa \`factucat customer search "${normalizedRef}"\` para revisar coincidencias.`);
+    }
+    throw new Error(`Encontré varios clientes para \`${normalizedRef}\`. Usa \`factucat customer search "${normalizedRef}"\` o pasa \`--customer-id\`.`);
+}
+function getOwnerUserLabel(me) {
+    if (me.ownerUserName && me.ownerUserEmail) {
+        return `${me.ownerUserName} (${me.ownerUserEmail})`;
+    }
+    if (me.ownerUserEmail) {
+        return me.ownerUserEmail;
+    }
+    if (me.ownerUserName) {
+        return me.ownerUserName;
+    }
+    return me.ownerUserId;
+}
+function formatTaxRateLabel(rate) {
+    return `${Number((rate * 100).toFixed(2))}%`;
+}
+function formatDraftItemLine(input) {
+    const satCode = input.productCode ?? input.suggestedProductCode ?? '-';
+    return [
+        `${input.id}  ${input.quantity} x ${input.description}  ${input.amount} ${input.currency}`,
+        `  SAT: ${satCode} · Unidad: ${input.unitCode} · IVA trasladado: ${formatTaxRateLabel(input.vatRate)} · ISR retenido: ${formatTaxRateLabel(input.isrWithholdingRate)}`,
+    ];
+}
+function formatIsoDateLabel(value) {
+    if (!value) {
+        return undefined;
+    }
+    return value.split('T')[0] ?? value;
+}
+function formatOptionalValue(label, value) {
+    return `${label}: ${value === undefined || value === null || value === '' ? '-' : value}`;
+}
+function formatPreviewItemLine(input) {
+    const satCode = input.productCode ?? input.suggestedProductCode ?? '-';
+    return [
+        `${input.index}. ${input.description}`,
+        `   Cantidad: ${input.quantity} · Precio unitario: ${input.unitPrice} ${input.currency} · Importe: ${input.amount} ${input.currency}`,
+        `   SAT: ${satCode} · Unidad: ${input.unitCode} · IVA trasladado: ${formatTaxRateLabel(input.vatRate)} · ISR retenido: ${formatTaxRateLabel(input.isrWithholdingRate)}`,
+    ];
+}
+function formatDraftPreview(draft) {
+    const lines = [
+        `Factura: ${draft.id}`,
+        `Estado: ${draft.status}`,
+        formatOptionalValue('Serie', draft.serie),
+        formatOptionalValue('Folio', draft.folio),
+        formatOptionalValue('UUID SAT', draft.satUuid),
+        '',
+        'Receptor:',
+        formatOptionalValue('  Razón social', draft.receiverLegalName),
+        formatOptionalValue('  RFC', draft.receiverRfc),
+        formatOptionalValue('  Código postal', draft.receiverPostalCode),
+        formatOptionalValue('  Régimen fiscal', draft.receiverTaxRegime),
+        formatOptionalValue('  Residencia fiscal', draft.receiverFiscalResidence),
+        formatOptionalValue('  Tax ID', draft.receiverTaxId),
+        formatOptionalValue('  Correo', draft.receiverEmail),
+        '',
+        'Comprobante:',
+        formatOptionalValue('  Tipo CFDI', draft.cfdiType),
+        formatOptionalValue('  Uso CFDI', draft.cfdiUse),
+        formatOptionalValue('  Método de pago', draft.paymentMethod),
+        formatOptionalValue('  Forma de pago', draft.paymentForm),
+        formatOptionalValue('  Moneda', draft.currency),
+        formatOptionalValue('  Tipo de cambio', draft.exchangeRate),
+        formatOptionalValue('  Fecha TC', formatIsoDateLabel(draft.exchangeRateDate)),
+        formatOptionalValue('  Idioma PDF', draft.pdfLanguage),
+        formatOptionalValue('  Notas', draft.customerNotes),
+        '',
+        `Conceptos (${draft.items.length}):`,
+        ...(draft.items.length > 0
+            ? draft.items.flatMap((item, index) => formatPreviewItemLine({
+                index: index + 1,
+                description: item.description,
+                quantity: item.quantity,
+                unitPrice: item.unitPrice,
+                amount: item.amount,
+                currency: draft.currency,
+                productCode: item.productCode,
+                suggestedProductCode: item.suggestedProductCode,
+                unitCode: item.unitCode,
+                vatRate: item.vatRate,
+                isrWithholdingRate: item.isrWithholdingRate,
+            }))
+            : ['Sin conceptos todavía.']),
+        '',
+        'Totales:',
+        `  Subtotal: ${draft.subtotal} ${draft.currency}`,
+        `  Impuestos: ${draft.taxTotal} ${draft.currency}`,
+        `  Total: ${draft.total} ${draft.currency}`,
+        formatOptionalValue('  Emitida', formatIsoDateLabel(draft.issuedAt)),
+        formatOptionalValue('  Cancelada', formatIsoDateLabel(draft.cancelledAt)),
+        formatOptionalValue('  Error', draft.errorMessage),
+    ];
+    return lines;
+}
+function formatDeliverySummary(input) {
+    const lines = [];
+    const requestedDelivery = Boolean(input.sendCustomerEmail || input.sendCustomerWhatsApp);
+    const sendInvoicesEnabled = input.customer?.sendInvoices ?? false;
+    if (requestedDelivery && !input.customer) {
+        return [
+            'Se solicitó entrega al cliente, pero este borrador no tiene un cliente ligado con contactos registrados.',
+        ];
+    }
+    if (requestedDelivery && !sendInvoicesEnabled) {
+        return [
+            'Se solicitó entrega al cliente, pero el cliente tiene desactivado el envío de facturas.',
+        ];
+    }
+    if (!sendInvoicesEnabled) {
+        return lines;
+    }
+    if (input.sendCustomerEmail) {
+        lines.push(input.customer?.email
+            ? `Entrega solicitada por correo: ${input.customer.email}`
+            : 'Se solicitó entrega por correo, pero el cliente no tiene email registrado.');
+    }
+    if (input.sendCustomerWhatsApp) {
+        lines.push(input.customer?.whatsappPhone
+            ? `Entrega solicitada por WhatsApp: ${input.customer.whatsappPhone}`
+            : 'Se solicitó entrega por WhatsApp, pero el cliente no tiene número registrado.');
+    }
+    return lines;
+}
+async function loadDraftCustomer(sdk, draft) {
+    if (!draft.customerId) {
+        return null;
+    }
+    try {
+        return await sdk.getCustomer(draft.customerId);
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveInteractiveStampInput(input) {
+    const customer = await loadDraftCustomer(input.sdk, input.draft);
+    printHuman(formatDraftPreview(input.draft));
+    const confirmed = await confirm({
+        message: '¿Timbramos esta factura ahora?',
+        active: 'Sí, timbrar',
+        inactive: 'No, cancelar',
+        initialValue: true,
+    });
+    if (isCancel(confirmed) || !confirmed) {
+        outro('Timbrado cancelado.');
+        return null;
+    }
+    if (input.options.sendToCustomerContacts !== undefined ||
+        input.options.sendCustomerEmail !== undefined ||
+        input.options.sendCustomerWhatsApp !== undefined) {
+        return {
+            stampInput: {
+                sendToCustomerContacts: input.options.sendToCustomerContacts,
+                sendCustomerEmail: input.options.sendCustomerEmail,
+                sendCustomerWhatsApp: input.options.sendCustomerWhatsApp,
+            },
+            customer,
+        };
+    }
+    if (!customer?.sendInvoices) {
+        return {
+            stampInput: {},
+            customer,
+        };
+    }
+    const canSendEmail = Boolean(customer.email);
+    const canSendWhatsApp = Boolean(customer.whatsappPhone);
+    if (!canSendEmail && !canSendWhatsApp) {
+        return {
+            stampInput: {},
+            customer,
+        };
+    }
+    const deliveryChoice = await select({
+        message: 'Después de timbrarla, ¿quieres que la enviemos al cliente?',
+        options: [
+            { value: 'none', label: 'No enviar todavía' },
+            ...(canSendEmail && canSendWhatsApp
+                ? [{
+                        value: 'both',
+                        label: 'Sí, por correo y WhatsApp',
+                        hint: `${customer.email} · ${customer.whatsappPhone}`,
+                    }]
+                : []),
+            ...(canSendEmail
+                ? [{ value: 'email', label: 'Sí, solo por correo', hint: customer.email }]
+                : []),
+            ...(canSendWhatsApp
+                ? [{
+                        value: 'whatsapp',
+                        label: 'Sí, solo por WhatsApp',
+                        hint: customer.whatsappPhone,
+                    }]
+                : []),
+        ],
+        initialValue: canSendEmail && canSendWhatsApp
+            ? 'both'
+            : canSendEmail
+                ? 'email'
+                : canSendWhatsApp
+                    ? 'whatsapp'
+                    : 'none',
+    });
+    if (isCancel(deliveryChoice)) {
+        outro('Timbrado cancelado.');
+        return null;
+    }
+    return {
+        stampInput: {
+            sendCustomerEmail: deliveryChoice === 'both' || deliveryChoice === 'email',
+            sendCustomerWhatsApp: deliveryChoice === 'both' || deliveryChoice === 'whatsapp',
+        },
+        customer,
+    };
+}
+function parseVatFlag(value) {
+    const normalized = value.trim();
+    const parsed = Number(normalized);
+    if (Number.isNaN(parsed)) {
+        throw new Error('IVA inválido. Usa 0, 10 o 16.');
+    }
+    if (parsed === 0 || parsed === 0.1 || parsed === 0.16) {
+        return parsed;
+    }
+    if (parsed === 10) {
+        return 0.1;
+    }
+    if (parsed === 16) {
+        return 0.16;
+    }
+    throw new Error('IVA inválido. Usa 0, 10 o 16.');
+}
+function parseIsrWithholdingFlag(value) {
+    const normalized = value.trim();
+    const parsed = Number(normalized);
+    if (Number.isNaN(parsed)) {
+        throw new Error('ISR retenido inválido. Usa 0, 1.25 o 10.');
+    }
+    if (parsed === 0 || parsed === 0.0125 || parsed === 0.1) {
+        return parsed;
+    }
+    if (parsed === 1.25) {
+        return 0.0125;
+    }
+    if (parsed === 10) {
+        return 0.1;
+    }
+    throw new Error('ISR retenido inválido. Usa 0, 1.25 o 10.');
+}
+async function main() {
+    const { argv, showHelp } = normalizeArgv(process.argv);
+    if (showHelp) {
+        printHuman(HELP_TEXT.trim().split('\n'));
+        return;
+    }
+    const cli = cac('factucat');
+    cli
+        .command('auth-api-key-set', 'Guardar API key')
+        .option('--value <apiKey>', 'API key a guardar')
+        .action(async (options) => {
+        const stdinValue = await readStdinValue();
+        let value = options.value?.trim() || stdinValue;
+        if (!value) {
+            if (!process.stdin.isTTY || !process.stdout.isTTY) {
+                throw new Error('No se detectó terminal interactiva. Usa `--value <apiKey>` o envía la API key por stdin.');
+            }
+            intro('Configurar API key');
+            const promptValue = await text({
+                message: 'Pega tu API key de FactuCat',
+                placeholder: 'fc_live_...',
+                validate(input) {
+                    return (input ?? '').trim().length > 0
+                        ? undefined
+                        : 'La API key es obligatoria.';
+                },
+            });
+            if (isCancel(promptValue)) {
+                outro('Cancelado.');
+                return;
+            }
+            value = promptValue.trim();
+        }
+        const config = await readConfig();
+        await writeConfig({
+            ...config,
+            apiKey: value,
+        });
+        outro('API key guardada.');
+    });
+    cli
+        .command('auth-api-key-show', 'Mostrar API key actual')
+        .action(async () => {
+        const config = await readConfig();
+        const apiKey = process.env.FACTUCAT_API_KEY ?? config.apiKey;
+        printHuman([apiKey ? apiKey : 'No hay API key configurada.']);
+    });
+    cli
+        .command('auth-api-key-clear', 'Eliminar API key guardada')
+        .action(async () => {
+        const config = await readConfig();
+        await writeConfig({
+            ...config,
+            apiKey: undefined,
+        });
+        outro('API key eliminada.');
+    });
+    withJsonFlag(cli.command('auth-status', 'Validar autenticación')).action(async (options) => {
+        const sdk = await getSdk();
+        const me = await sdk.getMe();
+        if (options.json) {
+            printJson(me);
+            return;
+        }
+        printHuman([
+            'Autenticación correcta.',
+            `Actor: ${me.actorType}`,
+            `Owner user: ${getOwnerUserLabel(me)}`,
+            `Scopes: ${me.scopes.join(', ')}`,
+        ]);
+    });
+    withJsonFlag(cli
+        .command('invoice-create', 'Crear borrador remoto')
+        .option('--customer-id <customerId>', 'ID del cliente')
+        .option('--customer <customerName>', 'Busca el cliente por nombre o RFC y lo asigna automáticamente al borrador')
+        .option('--draft', 'Crear y dejar como borrador')
+        .option('--no-input', 'Nunca preguntar datos faltantes')).action(async (options) => {
+        const commandOptions = options;
+        const sdk = await getSdk();
+        const resolvedCustomer = commandOptions.customerId
+            ? await sdk.getCustomer(commandOptions.customerId)
+            : commandOptions.customer
+                ? await resolveCustomerReference({
+                    sdk,
+                    customerRef: commandOptions.customer,
+                })
+                : null;
+        const draft = await sdk.createDraft(resolvedCustomer ? { customerId: resolvedCustomer.id } : {}, { idempotencyKey: randomUUID() });
+        await setCurrentDraftId(draft.id);
+        if (commandOptions.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([
+            `Borrador creado: ${draft.id}`,
+            `Cliente: ${resolvedCustomer?.legalName ?? 'sin resolver'}`,
+            'Usa `factucat invoice add-item` para agregar conceptos.',
+        ]);
+    });
+    withJsonFlag(cli.command('invoice-use <draftId>', 'Seleccionar borrador actual')).action(async (draftId, options) => {
+        await setCurrentDraftId(draftId);
+        if (options.json) {
+            printJson({ currentDraftId: draftId });
+            return;
+        }
+        printHuman([`Borrador activo: ${draftId}`]);
+    });
+    withJsonFlag(cli.command('invoice-current', 'Ver borrador activo')).action(async (options) => {
+        const currentDraftId = await getCurrentDraftId();
+        if (options.json) {
+            printJson({ currentDraftId: currentDraftId ?? null });
+            return;
+        }
+        printHuman([
+            currentDraftId
+                ? `Borrador activo: ${currentDraftId}`
+                : 'No hay borrador activo.',
+        ]);
+    });
+    withJsonFlag(cli
+        .command('invoice-show', 'Mostrar previa completa del borrador')
+        .option('--draft-id <draftId>', 'ID del borrador')).action(async (options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const draft = await sdk.getDraft(draftId);
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman(formatDraftPreview(draft));
+    });
+    withJsonFlag(cli
+        .command('invoice-list', 'Listar facturas')
+        .option('--status <status>', 'Estado')
+        .option('--query <query>', 'Búsqueda')
+        .option('--limit <limit>', 'Límite')).action(async (options) => {
+        const commandOptions = options;
+        const sdk = await getSdk();
+        const input = {
+            status: commandOptions.status,
+            query: commandOptions.query,
+            limit: commandOptions.limit ? Number(commandOptions.limit) : undefined,
+        };
+        const invoices = await sdk.listInvoices(input);
+        if (commandOptions.json) {
+            printJson(invoices);
+            return;
+        }
+        printHuman(invoices.map((invoice) => `${invoice.id}  ${invoice.folio}  ${invoice.status}  ${invoice.receiverLegalName}`));
+    });
+    withJsonFlag(cli
+        .command('invoice-set-customer', 'Asignar cliente al borrador actual')
+        .option('--id <customerId>', 'ID del cliente')
+        .option('--draft-id <draftId>', 'ID del borrador')).action(async (options) => {
+        if (!options.id) {
+            throw new Error('Debes indicar `--id <customerId>`.');
+        }
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const draft = await sdk.setDraftReceiver(draftId, { customerId: options.id }, { idempotencyKey: randomUUID() });
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([`Cliente asignado al borrador ${draft.id}.`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-set-receiver', 'Actualizar datos del receptor')
+        .option('--draft-id <draftId>', 'ID del borrador')
+        .option('--rfc <rfc>', 'RFC del receptor')
+        .option('--legal-name <legalName>', 'Razón social del receptor')
+        .option('--postal-code <postalCode>', 'Código postal del receptor')
+        .option('--tax-regime <taxRegime>', 'Régimen fiscal del receptor')
+        .option('--email <email>', 'Correo del receptor')).action(async (options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const input = {
+            receiverRfc: options.rfc,
+            receiverLegalName: options.legalName,
+            receiverPostalCode: options.postalCode,
+            receiverTaxRegime: options.taxRegime,
+            receiverEmail: options.email,
+        };
+        const draft = await sdk.setDraftReceiver(draftId, input, {
+            idempotencyKey: randomUUID(),
+        });
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([`Receptor actualizado en ${draft.id}.`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-set-meta', 'Actualizar metadatos del borrador. Si usas USD sin --exchange-rate, se consulta automáticamente el DOF.')
+        .option('--draft-id <draftId>', 'ID del borrador')
+        .option('--cfdi-use <cfdiUse>', 'Uso CFDI')
+        .option('--payment-method <paymentMethod>', 'Método de pago')
+        .option('--payment-form <paymentForm>', 'Forma de pago')
+        .option('--currency <currency>', 'Moneda')
+        .option('--exchange-rate <exchangeRate>', 'Tipo de cambio. Si lo omites y usas USD, se infiere automáticamente desde el DOF.')
+        .option('--vat-rate <vatRate>', 'Tasa de IVA')
+        .option('--customer-notes <customerNotes>', 'Notas para el cliente')).action(async (options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const input = {
+            cfdiUse: options.cfdiUse,
+            paymentMethod: options.paymentMethod,
+            paymentForm: options.paymentForm,
+            currency: options.currency,
+            exchangeRate: options.exchangeRate === undefined ? undefined : Number(options.exchangeRate),
+            vatRate: options.vatRate === undefined
+                ? undefined
+                : Number(options.vatRate),
+            customerNotes: options.customerNotes,
+        };
+        const autoResolvedExchangeRate = options.currency !== undefined && options.exchangeRate === undefined;
+        const exchangeRateLoading = !options.json &&
+            options.currency === 'USD' &&
+            options.exchangeRate === undefined
+            ? spinner()
+            : null;
+        if (exchangeRateLoading) {
+            exchangeRateLoading.start('Consultando tipo de cambio oficial del DOF...');
+        }
+        const draft = await sdk.setDraftMeta(draftId, input, {
+            idempotencyKey: randomUUID(),
+        });
+        if (exchangeRateLoading) {
+            exchangeRateLoading.stop('Tipo de cambio aplicado al borrador.');
+        }
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        const lines = [`Metadatos actualizados en ${draft.id}.`];
+        if (autoResolvedExchangeRate) {
+            const exchangeRateDate = formatIsoDateLabel(draft.exchangeRateDate);
+            lines.push(exchangeRateDate
+                ? `Tipo de cambio aplicado automáticamente: ${draft.exchangeRate} · Fecha: ${exchangeRateDate}`
+                : `Tipo de cambio aplicado automáticamente: ${draft.exchangeRate}`);
+        }
+        printHuman(lines);
+    });
+    withJsonFlag(cli
+        .command('invoice-add-item', 'Agregar concepto al borrador. Si omites Clave SAT, unidad o impuestos, FactuCat intenta inferirlos automáticamente.')
+        .option('--draft-id <draftId>', 'ID del borrador')
+        .option('--description <description>', 'Descripción')
+        .option('--unit-price <unitPrice>', 'Precio unitario')
+        .option('--quantity <quantity>', 'Cantidad', { default: '1' })
+        .option('--iva <iva>', 'IVA del concepto: 0, 10 o 16. Si lo omites, se infiere automáticamente.')
+        .option('--vat <vat>', 'Alias de compatibilidad para `--iva`')
+        .option('--isr-retenido <isrRetenido>', 'ISR retenido: 0, 1.25 o 10. Si lo omites, se infiere automáticamente.')
+        .option('--isr-withholding <isrWithholding>', 'Alias de compatibilidad para `--isr-retenido`')
+        .option('--product-code <productCode>', 'Clave SAT del producto. Si la omites, se intenta inferir automáticamente.')
+        .option('--unit-code <unitCode>', 'Clave SAT de unidad. Si la omites, se intenta inferir automáticamente.')).action(async (options) => {
+        if (!options.description || !options.unitPrice) {
+            throw new Error('Debes indicar `--description <description>` y `--unit-price <unitPrice>`.');
+        }
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const iva = options.iva ?? options.vat;
+        const isrRetenido = options.isrRetenido ?? options.isrWithholding;
+        const input = {
+            description: options.description,
+            quantity: Number(options.quantity),
+            unitPrice: Number(options.unitPrice),
+            vatRate: iva === undefined ? undefined : parseVatFlag(iva),
+            vatSource: iva === undefined ? undefined : 'manual',
+            isrWithholdingRate: isrRetenido === undefined
+                ? undefined
+                : parseIsrWithholdingFlag(isrRetenido),
+            isrWithholdingSource: isrRetenido === undefined ? undefined : 'manual',
+            productCode: options.productCode,
+            unitCode: options.unitCode,
+        };
+        const shouldShowSatInferenceLoading = !options.json && !options.productCode && !options.unitCode;
+        const loading = shouldShowSatInferenceLoading ? spinner() : null;
+        if (loading) {
+            loading.start('Infiriendo la clave SAT de este concepto...');
+        }
+        const draft = await sdk.addDraftItem(draftId, input, {
+            idempotencyKey: randomUUID(),
+        });
+        if (loading) {
+            loading.stop('Concepto clasificado y agregado al borrador.');
+        }
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([`Concepto agregado. Total actual: ${draft.total} ${draft.currency}`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-update-item <itemId>', 'Actualizar concepto')
+        .option('--draft-id <draftId>', 'ID del borrador')
+        .option('--description <description>', 'Descripción')
+        .option('--unit-price <unitPrice>', 'Precio unitario')
+        .option('--quantity <quantity>', 'Cantidad')
+        .option('--product-code <productCode>', 'Clave SAT del producto')
+        .option('--unit-code <unitCode>', 'Clave SAT de unidad')).action(async (itemId, options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const input = {
+            description: options.description,
+            quantity: options.quantity === undefined ? undefined : Number(options.quantity),
+            unitPrice: options.unitPrice === undefined ? undefined : Number(options.unitPrice),
+            productCode: options.productCode,
+            unitCode: options.unitCode,
+        };
+        const draft = await sdk.updateDraftItem(draftId, itemId, input, {
+            idempotencyKey: randomUUID(),
+        });
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([`Concepto actualizado. Total actual: ${draft.total} ${draft.currency}`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-remove-item <itemId>', 'Eliminar concepto')
+        .option('--draft-id <draftId>', 'ID del borrador')).action(async (itemId, options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const draft = await sdk.removeDraftItem(draftId, itemId, {
+            idempotencyKey: randomUUID(),
+        });
+        if (options.json) {
+            printJson(draft);
+            return;
+        }
+        printHuman([`Concepto eliminado. Total actual: ${draft.total} ${draft.currency}`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-items', 'Listar conceptos del borrador')
+        .option('--draft-id <draftId>', 'ID del borrador')).action(async (options) => {
+        const sdk = await getSdk();
+        const draft = await sdk.getDraft(await resolveDraftId(options.draftId));
+        if (options.json) {
+            printJson(draft.items);
+            return;
+        }
+        printHuman(draft.items.flatMap((item) => formatDraftItemLine({
+            id: item.id,
+            quantity: item.quantity,
+            description: item.description,
+            amount: item.amount,
+            currency: draft.currency,
+            productCode: item.productCode,
+            suggestedProductCode: item.suggestedProductCode,
+            unitCode: item.unitCode,
+            vatRate: item.vatRate,
+            isrWithholdingRate: item.isrWithholdingRate,
+        })));
+    });
+    withJsonFlag(cli
+        .command('invoice-discard', 'Eliminar borrador actual')
+        .option('--draft-id <draftId>', 'ID del borrador')).action(async (options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const result = await sdk.discardDraft(draftId, {
+            idempotencyKey: randomUUID(),
+        });
+        if ((await getCurrentDraftId()) === draftId) {
+            await setCurrentDraftId(undefined);
+        }
+        if (options.json) {
+            printJson(result);
+            return;
+        }
+        printHuman([`Borrador eliminado: ${result.id}`]);
+    });
+    withJsonFlag(cli
+        .command('invoice-stamp', 'Timbrar borrador actual. En modo interactivo muestra la previa y pregunta si quieres enviarla al cliente después.')
+        .option('--draft-id <draftId>', 'ID del borrador')
+        .option('--no-input', 'Nunca preguntar nada; útil para agentes y scripts')
+        .option('--send-to-customer-contacts', 'Solicita entrega por email y WhatsApp registrados en el cliente, si existen.')
+        .option('--send-customer-email', 'Solicita entrega por correo del cliente')
+        .option('--send-customer-whatsapp', 'Solicita entrega por WhatsApp del cliente')).action(async (options) => {
+        const sdk = await getSdk();
+        const draftId = await resolveDraftId(options.draftId);
+        const interactiveMode = canPromptInteractively(options);
+        const draft = interactiveMode ? await sdk.getDraft(draftId) : null;
+        const interactiveResolution = interactiveMode && draft
+            ? await resolveInteractiveStampInput({
+                sdk,
+                draft,
+                options,
+            })
+            : null;
+        if (interactiveMode && !interactiveResolution) {
+            return;
+        }
+        const shouldLoadCustomerForSummary = options.sendToCustomerContacts ||
+            options.sendCustomerEmail ||
+            options.sendCustomerWhatsApp;
+        const customer = interactiveResolution?.customer ??
+            (shouldLoadCustomerForSummary
+                ? await loadDraftCustomer(sdk, draft ?? (await sdk.getDraft(draftId)))
+                : null);
+        const stampInput = interactiveResolution?.stampInput ?? {
+            sendToCustomerContacts: options.sendToCustomerContacts,
+            sendCustomerEmail: options.sendCustomerEmail,
+            sendCustomerWhatsApp: options.sendCustomerWhatsApp,
+        };
+        const loading = !options.json ? spinner() : null;
+        if (loading) {
+            loading.start('Timbrando factura...');
+        }
+        const invoice = await sdk.stampDraft(draftId, stampInput, { idempotencyKey: randomUUID() });
+        if (loading) {
+            loading.stop('Factura timbrada.');
+        }
+        if ((await getCurrentDraftId()) === draftId) {
+            await setCurrentDraftId(undefined);
+        }
+        if (options.json) {
+            printJson(invoice);
+            return;
+        }
+        printHuman([
+            `Factura timbrada: ${invoice.id}`,
+            `Folio: ${invoice.folio ?? 'sin folio'}`,
+            `UUID SAT: ${invoice.satUuid ?? 'pendiente'}`,
+            ...formatDeliverySummary({
+                sendCustomerEmail: stampInput.sendCustomerEmail ??
+                    stampInput.sendToCustomerContacts,
+                sendCustomerWhatsApp: stampInput.sendCustomerWhatsApp ??
+                    stampInput.sendToCustomerContacts,
+                customer,
+            }),
+        ]);
+    });
+    withJsonFlag(cli.command('invoice-get <invoiceRef>', 'Obtener factura por UUID o folio')).action(async (invoiceRef, options) => {
+        const sdk = await getSdk();
+        const invoiceId = await resolveInvoiceReference({ sdk, invoiceRef });
+        const invoice = await sdk.getInvoice(invoiceId);
+        if (options.json) {
+            printJson(invoice);
+            return;
+        }
+        printHuman([
+            `Factura: ${invoice.id}`,
+            `Estado: ${invoice.status}`,
+            `Receptor: ${invoice.receiverLegalName}`,
+            `Total: ${invoice.total} ${invoice.currency}`,
+        ]);
+    });
+    withJsonFlag(cli.command('invoice-download-xml <invoiceRef>', 'Descargar XML timbrado por UUID o folio').option('--output <path>', 'Ruta destino. Puede ser archivo o carpeta. Si lo omites, se guarda en el directorio actual.')).action(async (invoiceRef, options) => {
+        const sdk = await getSdk();
+        const invoiceId = await resolveInvoiceReference({ sdk, invoiceRef });
+        const xml = await sdk.downloadInvoiceXml(invoiceId);
+        if (options.json) {
+            printJson(xml);
+            return;
+        }
+        const savedPath = await saveDownloadedArtifact({
+            base64: xml.base64,
+            fileName: xml.fileName,
+            output: options.output,
+        });
+        printHuman([`Archivo guardado en: ${savedPath}`, xml.mimeType]);
+    });
+    withJsonFlag(cli.command('invoice-download-pdf <invoiceRef>', 'Descargar PDF timbrado por UUID o folio').option('--output <path>', 'Ruta destino. Puede ser archivo o carpeta. Si lo omites, se guarda en el directorio actual.')).action(async (invoiceRef, options) => {
+        const sdk = await getSdk();
+        const invoiceId = await resolveInvoiceReference({ sdk, invoiceRef });
+        const pdf = await sdk.downloadInvoicePdf(invoiceId);
+        if (options.json) {
+            printJson(pdf);
+            return;
+        }
+        const savedPath = await saveDownloadedArtifact({
+            base64: pdf.base64,
+            fileName: pdf.fileName,
+            output: options.output,
+        });
+        printHuman([`Archivo guardado en: ${savedPath}`, pdf.mimeType]);
+    });
+    withJsonFlag(cli
+        .command('customer-list', 'Listar clientes')
+        .option('--query <query>', 'Búsqueda')
+        .option('--limit <limit>', 'Límite')).action(async (options) => {
+        const sdk = await getSdk();
+        const customers = await sdk.listCustomers({
+            query: options.query,
+            limit: options.limit ? Number(options.limit) : undefined,
+        });
+        if (options.json) {
+            printJson(customers);
+            return;
+        }
+        printHuman(customers.map((customer) => `${customer.id}  ${customer.legalName}`));
+    });
+    withJsonFlag(cli.command('customer-search <query>', 'Buscar clientes')).action(async (query, options) => {
+        const sdk = await getSdk();
+        const customers = await sdk.listCustomers({ query });
+        if (options.json) {
+            printJson(customers);
+            return;
+        }
+        printHuman(customers.map((customer) => `${customer.id}  ${customer.legalName}`));
+    });
+    withJsonFlag(cli
+        .command('customer-create', 'Crear cliente')
+        .option('--legal-name <legalName>', 'Razón social')
+        .option('--rfc <rfc>', 'RFC')
+        .option('--postal-code <postalCode>', 'Código postal')
+        .option('--tax-regime <taxRegime>', 'Régimen fiscal')
+        .option('--email <email>', 'Correo')
+        .option('--whatsapp-phone <whatsappPhone>', 'WhatsApp')
+        .option('--currency <currency>', 'Moneda')
+        .option('--invoice-language <invoiceLanguage>', 'Idioma de factura')).action(async (options) => {
+        if (!options.legalName || !options.rfc || !options.postalCode || !options.taxRegime) {
+            throw new Error('Debes indicar `--legal-name`, `--rfc`, `--postal-code` y `--tax-regime`.');
+        }
+        const sdk = await getSdk();
+        const input = {
+            legalName: options.legalName,
+            rfc: options.rfc,
+            postalCode: options.postalCode,
+            taxRegime: options.taxRegime,
+            email: options.email,
+            whatsappPhone: options.whatsappPhone,
+            currency: options.currency ?? 'MXN',
+            invoiceLanguage: options.invoiceLanguage ?? 'es',
+            sendInvoices: true,
+        };
+        const customer = await sdk.createCustomer(input, {
+            idempotencyKey: randomUUID(),
+        });
+        if (options.json) {
+            printJson(customer);
+            return;
+        }
+        printHuman([`Cliente creado: ${customer.id}`, customer.legalName]);
+    });
+    cli.help();
+    try {
+        cli.parse(argv, { run: false });
+        await Promise.resolve(cli.runMatchedCommand());
+    }
+    catch (error) {
+        if (wantsJson(argv)) {
+            printJson({
+                error: {
+                    message: getErrorMessage(error),
+                },
+            });
+        }
+        else {
+            process.stderr.write(`${getErrorMessage(error)}\n`);
+        }
+        process.exitCode = exitCodeFromError(error);
+    }
+}
+void main();
+//# sourceMappingURL=index.js.map