arcli 2.0.0 → 2.2.0

package/dist/modules/completion/installer.js

@@ -0,0 +1,92 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { COMPLETION_SHELLS } from './shell-scripts.js';
+/** Marca lo que agrega arcli, para reconocerlo y sacarlo despues sin tocar nada mas. */
+const MARKER = '# arcli: autocompletado con Tab (se saca con "arcli completado desinstalar")';
+export function currentCompletionEnvironment() {
+    return {
+        home: process.env.HOME ?? '',
+        platform: process.platform,
+        shell: process.env.SHELL,
+        xdgConfigHome: process.env.XDG_CONFIG_HOME,
+        zdotdir: process.env.ZDOTDIR,
+    };
+}
+/** El shell de `$SHELL`, si es uno que arcli sabe completar. */
+export function detectShell(shellPath) {
+    const name = shellPath ? basename(shellPath) : '';
+    return COMPLETION_SHELLS.find((shell) => shell === name);
+}
+/** Donde va el autocompletado: la linea en el rc de bash o zsh, o un archivo propio en fish. */
+export function resolveCompletionPath(shell, environment) {
+    if (shell === 'fish') {
+        return join(environment.xdgConfigHome ?? join(environment.home, '.config'), 'fish', 'completions', 'arcli.fish');
+    }
+    if (shell === 'zsh') {
+        return join(environment.zdotdir ?? environment.home, '.zshrc');
+    }
+    if (environment.platform !== 'darwin') {
+        return join(environment.home, '.bashrc');
+    }
+    // La Terminal de macOS abre bash como login shell: lee el primero que exista de estos. Crear .bash_profile
+    // cuando solo hay .profile haria que bash deje de leer .profile.
+    const loginFiles = ['.bash_profile', '.bash_login', '.profile'].map((name) => join(environment.home, name));
+    return loginFiles.find((path) => existsSync(path)) ?? loginFiles[0];
+}
+function activationLine(shell) {
+    return shell === 'fish'
+        ? 'arcli completado fish | source'
+        : `command -v arcli >/dev/null 2>&1 && eval "$(arcli completado ${shell})"`;
+}
+function readText(path) {
+    return existsSync(path) ? readFileSync(path, 'utf8') : '';
+}
+/** Lo agrego arcli o se agrego a mano: cualquier linea que active `arcli completado <shell>`. */
+function isActivationLine(line, shell) {
+    return line === MARKER || line.includes(`arcli completado ${shell}`);
+}
+export function getCompletionState(shell, environment) {
+    const path = resolveCompletionPath(shell, environment);
+    const installed = readText(path)
+        .split('\n')
+        .some((line) => line !== MARKER && isActivationLine(line, shell) && !line.trimStart().startsWith('#'));
+    return { installed, path, shell };
+}
+export function installCompletion(shell, environment) {
+    const state = getCompletionState(shell, environment);
+    if (state.installed) {
+        return { ...state, changed: false };
+    }
+    const block = `${MARKER}\n${activationLine(shell)}\n`;
+    mkdirSync(dirname(state.path), { recursive: true });
+    if (shell === 'fish') {
+        writeFileSync(state.path, block);
+    }
+    else {
+        const current = readText(state.path);
+        const separator = current === '' ? '' : current.endsWith('\n') ? '\n' : '\n\n';
+        writeFileSync(state.path, `${current}${separator}${block}`);
+    }
+    return { ...state, changed: true, installed: true };
+}
+export function uninstallCompletion(shell, environment) {
+    const state = getCompletionState(shell, environment);
+    const current = readText(state.path);
+    if (!current.includes(MARKER) && !state.installed) {
+        return { ...state, changed: false };
+    }
+    if (shell === 'fish') {
+        rmSync(state.path, { force: true });
+        return { ...state, changed: true, installed: false };
+    }
+    const lines = current.split('\n');
+    const kept = lines.filter((line, index) => {
+        if (isActivationLine(line, shell)) {
+            return false;
+        }
+        // La linea en blanco que se agrego antes del bloque tambien se va.
+        return !(line === '' && lines[index + 1] === MARKER);
+    });
+    writeFileSync(state.path, kept.join('\n'));
+    return { ...state, changed: true, installed: false };
+}

package/dist/modules/completion/shell-scripts.js

@@ -0,0 +1,46 @@
+export const COMPLETION_SHELLS = ['bash', 'zsh', 'fish'];
+/** Comando oculto que el script del shell llama en cada Tab. */
+export const COMPLETE_COMMAND = '__completar';
+/**
+ * Scripts minimos: cada Tab le pregunta a `arcli __completar` que sigue, asi la lista sale siempre de la version
+ * instalada. Sin candidatos, el shell completa rutas de archivo (para `--cargar` y las rutas de config).
+ */
+const SCRIPTS = {
+    bash: `# Autocompletado de arcli para bash. Activalo con: eval "$(arcli completado bash)"
+_arcli_completar() {
+  # Copiadas antes de cambiar IFS: bash 3.2 (el de macOS) junta "\${arr[@]:1:n}" en una palabra si IFS cambio.
+  local palabras=("\${COMP_WORDS[@]:1:COMP_CWORD}")
+  local IFS=$'\\n'
+  COMPREPLY=($(arcli ${COMPLETE_COMMAND} -- "\${palabras[@]}" 2>/dev/null))
+}
+complete -o default -F _arcli_completar arcli
+`,
+    fish: `# Autocompletado de arcli para fish. Activalo con: arcli completado fish | source
+function __arcli_completar
+    set -l palabras (commandline -opc)[2..-1] (commandline -ct)
+    set -l candidatos (arcli ${COMPLETE_COMMAND} -- $palabras 2>/dev/null)
+    if test (count $candidatos) -gt 0
+        printf '%s\\n' $candidatos
+    else
+        __fish_complete_path (commandline -ct)
+    end
+end
+complete -c arcli -f -a '(__arcli_completar)'
+`,
+    zsh: `# Autocompletado de arcli para zsh. Activalo con: eval "$(arcli completado zsh)"
+(( $+functions[compdef] )) || { autoload -Uz compinit && compinit; }
+_arcli() {
+  local -a candidatos
+  candidatos=("\${(@f)$(arcli ${COMPLETE_COMMAND} -- "\${(@)words[2,CURRENT]}" 2>/dev/null)}")
+  if (( \${#candidatos} )) && [[ -n "\${candidatos[1]}" ]]; then
+    compadd -- "\${candidatos[@]}"
+  else
+    _files
+  fi
+}
+compdef _arcli arcli
+`,
+};
+export function buildCompletionScript(shell) {
+    return SCRIPTS[shell];
+}

package/dist/modules/config/certificate-expiry.js

@@ -0,0 +1,90 @@
+import { readFileSync } from 'node:fs';
+import { formatArcaDateAsArgentineDate, formatDateAsArcaDate } from '../../lib/dates/arca-date.js';
+import { AppError } from '../../lib/errors/app-error.js';
+import { CERTIFICATE_GUIDE_URL } from '../../lib/links.js';
+import { isCertificateExpiringSoon, readCertificateExpiry, } from '../../lib/security/certificate.js';
+import { arcliEnvironmentSchema, formatEnvironmentLabel } from './config.schemas.js';
+/** A menos de estos dias de vencer, el certificado se avisa en cada comando y en `config revisar`. */
+export const CERTIFICATE_EXPIRY_WARNING_DAYS = 30;
+/** Fecha de vencimiento como dd/mm/aaaa del dia en Argentina. */
+export function formatCertificateExpiryDate(expiresAt) {
+    return formatArcaDateAsArgentineDate(formatDateAsArcaDate(expiresAt));
+}
+function formatDaysRemaining(days) {
+    if (days <= 0) {
+        return 'hoy';
+    }
+    return days === 1 ? 'en 1 día' : `en ${days} días`;
+}
+export function describeCertificateExpiry(expiry, environment) {
+    if (!expiry.isExpired && !isCertificateExpiringSoon(expiry, CERTIFICATE_EXPIRY_WARNING_DAYS)) {
+        return undefined;
+    }
+    const expiresOn = formatCertificateExpiryDate(expiry.expiresAt);
+    const status = expiry.isExpired
+        ? `venció el ${expiresOn}`
+        : `vence el ${expiresOn} (${formatDaysRemaining(expiry.daysRemaining)})`;
+    const summary = `El certificado de ${formatEnvironmentLabel(environment)} ${status}.`;
+    return {
+        daysRemaining: expiry.daysRemaining,
+        environment,
+        expired: expiry.isExpired,
+        expiresOn,
+        message: `${summary} Renovalo: ${CERTIFICATE_GUIDE_URL}`,
+        summary,
+    };
+}
+/**
+ * Aviso del certificado ya leido (PEM). Si no se puede leer la fecha, no hay aviso: el error de un certificado
+ * invalido lo informa el flujo de siempre (WSAA o `config revisar`).
+ */
+export function inspectCertificateExpiry(pemContent, environment, now = new Date()) {
+    try {
+        return describeCertificateExpiry(readCertificateExpiry(pemContent, now), environment);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Avisos de todos los certificados configurados (testing y produccion), sin importar con cual se trabaja: quien
+ * factura en testing tambien tiene que enterarse de que vence el de produccion. El del entorno activo va primero.
+ * Un certificado sin configurar o que no se puede leer no avisa.
+ */
+export function inspectConfiguredCertificates(certPaths, options) {
+    const environments = arcliEnvironmentSchema.options.filter((environment) => environment !== options.activeEnvironment);
+    const notices = [];
+    for (const environment of [options.activeEnvironment, ...environments]) {
+        const pem = environment === options.activeEnvironment ? options.activePem : undefined;
+        const content = pem ?? readCertificateQuietly(certPaths[environment]);
+        const notice = content === undefined ? undefined : inspectCertificateExpiry(content, environment, options.now);
+        if (notice) {
+            notices.push(notice);
+        }
+    }
+    return notices;
+}
+function readCertificateQuietly(filePath) {
+    if (!filePath) {
+        return undefined;
+    }
+    try {
+        return readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Con el certificado vencido WSAA rechaza el login: se corta antes, sin ir a ARCA. */
+export class CertificateExpiredError extends AppError {
+    notice;
+    constructor(notice) {
+        super(`El certificado de ${formatEnvironmentLabel(notice.environment)} venció el ${notice.expiresOn}: ARCA no lo acepta.`, {
+            code: 'CERTIFICATE_EXPIRED',
+            details: { entorno: notice.environment, vencimiento: notice.expiresOn },
+            suggestion: `Generá uno nuevo siguiendo la guía y cargalo con "arcli config establecer cert.${notice.environment} <ruta>": ${CERTIFICATE_GUIDE_URL}`,
+        });
+        this.name = 'CertificateExpiredError';
+        this.notice = notice;
+    }
+}

package/dist/modules/config/config-doctor.js

@@ -2,7 +2,8 @@ import { CERTIFICATE_GUIDE_URL } from '../../lib/links.js';
 import { isCertificateExpiringSoon, readCertificateExpiry } from '../../lib/security/certificate.js';
 import { readPemFile } from '../../lib/security/pem.js';
 import { listMissingIssuerKeys } from '../pdf/pdf-issuer.js';
-const CERTIFICATE_EXPIRY_WARNING_DAYS = 30;
+import { CERTIFICATE_EXPIRY_WARNING_DAYS, formatCertificateExpiryDate } from './certificate-expiry.js';
+import { arcliEnvironmentSchema, formatEnvironmentLabel, } from './config.schemas.js';
 function buildCertificateExpiryCheck(label, certPath) {
     if (!certPath) {
         return null;
@@ -10,14 +11,14 @@ function buildCertificateExpiryCheck(label, certPath) {
     try {
         const pemContent = readPemFile(certPath, 'certificado');
         const expiry = readCertificateExpiry(pemContent);
-        const formattedDate = expiry.expiresAt.toLocaleDateString('es-AR');
+        const formattedDate = formatCertificateExpiryDate(expiry.expiresAt);
         if (expiry.isExpired) {
-            return { category: 'error', detail: `El certificado vencio el ${formattedDate}.`, label };
+            return { category: 'error', detail: `El certificado venció el ${formattedDate}.`, label };
         }
         if (isCertificateExpiringSoon(expiry, CERTIFICATE_EXPIRY_WARNING_DAYS)) {
             return {
                 category: 'warning',
-                detail: `El certificado vence en ${expiry.daysRemaining} dias (${formattedDate}). Renuevelo pronto.`,
+                detail: `El certificado vence en ${expiry.daysRemaining} días (${formattedDate}). Renuevelo pronto.`,
                 label,
             };
         }
@@ -31,20 +32,20 @@ function buildCertificateExpiryCheck(label, certPath) {
         };
     }
 }
-export function buildConfigDoctorReport(config, runtimeCheck) {
+export function buildConfigDoctorReport(config, runtimeChecks = []) {
     const checks = [];
     const conditionalChecks = [
         {
             label: 'CUIT',
             ok: config.cuit,
             okDetail: 'CUIT listo para emitir comprobantes.',
-            warningDetail: 'Configure su CUIT con "arcli config establecer cuit <valor>".',
+            warningDetail: 'Configurá su CUIT con "arcli config establecer cuit <valor>".',
         },
         {
             label: 'Punto de venta',
             ok: config.puntoVentaPorDefecto,
             okDetail: `Punto de venta por defecto: ${config.puntoVentaPorDefecto}.`,
-            warningDetail: 'Configure un punto de venta por defecto con "arcli config establecer puntoVenta <valor>".',
+            warningDetail: 'Configurá un punto de venta por defecto con "arcli config establecer puntoVenta <valor>".',
         },
         {
             label: 'Concepto',
@@ -62,13 +63,13 @@ export function buildConfigDoctorReport(config, runtimeCheck) {
             label: 'Credenciales testing',
             ok: config.cert.testing && config.key.testing,
             okDetail: 'Certificado y clave de testing configurados.',
-            warningDetail: `Faltan credenciales de testing. Configure "cert.testing" y "key.testing" con "arcli config establecer". Si todavia no tiene certificado: ${CERTIFICATE_GUIDE_URL}`,
+            warningDetail: `Faltan credenciales de testing. Configurá "cert.testing" y "key.testing" con "arcli config establecer". Si todavia no tiene certificado: ${CERTIFICATE_GUIDE_URL}`,
         },
         {
-            label: 'Credenciales produccion',
+            label: 'Credenciales producción',
             ok: config.cert.produccion && config.key.produccion,
-            okDetail: 'Certificado y clave de produccion configurados.',
-            warningDetail: 'Todavia no hay credenciales de produccion configuradas. Puede cargarlas con "cert.produccion" y "key.produccion".',
+            okDetail: 'Certificado y clave de producción configurados.',
+            warningDetail: 'Todavía no hay credenciales de producción configuradas. Puede cargarlas con "cert.produccion" y "key.produccion".',
         },
     ];
     for (const check of conditionalChecks) {
@@ -78,13 +79,34 @@ export function buildConfigDoctorReport(config, runtimeCheck) {
     }
     for (const [label, certPath] of [
         ['Vencimiento cert. testing', config.cert.testing],
-        ['Vencimiento cert. produccion', config.cert.produccion],
+        ['Vencimiento cert. producción', config.cert.produccion],
+        ['Vencimiento cert. exportación testing', config.exportacion?.cert.testing],
+        ['Vencimiento cert. exportación producción', config.exportacion?.cert.produccion],
     ]) {
         const certificateCheck = buildCertificateExpiryCheck(label, certPath);
         if (certificateCheck) {
             checks.push(certificateCheck);
         }
     }
+    // WSFEX es opcional: solo se avisa si hay algo configurado a medias.
+    for (const environment of arcliEnvironmentSchema.options) {
+        const cert = config.exportacion?.cert[environment];
+        const key = config.exportacion?.key[environment];
+        if (!cert && !key) {
+            continue;
+        }
+        checks.push(cert && key
+            ? {
+                category: 'ok',
+                detail: `Certificado y clave de exportación (${environment}) configurados.`,
+                label: 'Credenciales WSFEX',
+            }
+            : {
+                category: 'warning',
+                detail: `Para WSFEX en ${environment} configurá "exportacion.cert.${environment}" y "exportacion.key.${environment}" juntos.`,
+                label: 'Credenciales WSFEX',
+            });
+    }
     checks.push({
         category: 'ok',
         detail: `Entorno por defecto: ${config.entornoPorDefecto}.`,
@@ -93,7 +115,7 @@ export function buildConfigDoctorReport(config, runtimeCheck) {
     checks.push({
         category: 'ok',
         detail: `Emitir por defecto: ${config.output.emitirPorDefecto ? 'si' : 'no'}.`,
-        label: 'Emision',
+        label: 'Emisión',
     });
     checks.push({
         category: 'ok',
@@ -113,27 +135,19 @@ export function buildConfigDoctorReport(config, runtimeCheck) {
     else if (config.pdf === 'siempre') {
         checks.push({
             category: 'warning',
-            detail: `Con pdf=siempre faltan datos del emisor: ${missingIssuerKeys.join(', ')}. Configurelos con "arcli config establecer".`,
+            detail: `Con pdf=siempre faltan datos del emisor: ${missingIssuerKeys.join(', ')}. Configuralos con "arcli config establecer".`,
             label: 'PDF',
         });
     }
-    if (runtimeCheck?.validation) {
-        checks.push({
-            category: 'ok',
-            detail: `Configuracion valida para ${runtimeCheck.validation.environment}.`,
-            label: 'Revision activa',
-        });
-    }
-    else if (runtimeCheck?.error) {
-        checks.push({
-            category: 'error',
-            detail: runtimeCheck.error,
-            label: 'Revision activa',
-        });
+    for (const runtimeCheck of runtimeChecks) {
+        const environment = formatEnvironmentLabel(runtimeCheck.environment);
+        const label = `Validación ${environment}`;
+        checks.push(runtimeCheck.error
+            ? { category: 'error', detail: runtimeCheck.error, label }
+            : { category: 'ok', detail: `Configuración válida para ${environment}.`, label });
     }
     return {
         checks,
         ok: checks.every((check) => check.category === 'ok'),
     };
 }
-//# sourceMappingURL=config-doctor.js.map

package/dist/modules/config/config-value-parser.js

@@ -1,7 +1,10 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { parseArgentineDateInputAsArcaDate } from '../../lib/dates/arca-date.js';
+import { InputValidationError } from '../../lib/errors/app-error.js';
+import { parseCuit } from '../../lib/identity/cuit.js';
 import { EXCHANGE_RATE_DECIMALS, parseArgentineAmount } from '../../lib/numbers/argentine-amount.js';
+import { parseStrictInteger } from '../../lib/numbers/strict-integer.js';
 import { readPemFile } from '../../lib/security/pem.js';
 import { IVA_RATE_HINT } from '../billing/billing.schemas.js';
 import { MAX_RECENT_VOUCHERS } from '../vouchers/voucher-history.js';
@@ -14,54 +17,61 @@ function parseBoolean(value) {
     if (normalizedValue === 'false' || normalizedValue === '0' || normalizedValue === 'no') {
         return false;
     }
-    throw new Error(`El valor "${value}" no es un booleano valido. Use true/false, si/no o 1/0.`);
+    throw new InputValidationError(`El valor "${value}" no es un booleano válido. Usá true/false, si/no o 1/0.`);
 }
 function parseNonEmptyString(value) {
     const normalizedValue = value.trim();
     if (!normalizedValue) {
-        throw new Error('El valor no puede estar vacio.');
+        throw new InputValidationError('El valor no puede estar vacío.');
     }
     return normalizedValue;
 }
 function parseIvaRate(value) {
     const result = arcliDefaultIvaRateSchema.safeParse(value);
     if (!result.success) {
-        throw new Error(`La alicuota "${value}" no es valida. Use ${IVA_RATE_HINT}.`);
+        throw new InputValidationError(`La alícuota "${value}" no es válida. Usá ${IVA_RATE_HINT}.`);
     }
     return result.data;
 }
+function parseConfigCuit(value) {
+    const result = parseCuit(value);
+    if (!result.ok) {
+        throw new InputValidationError(`El CUIT "${value}" no es válido: ${result.reason}.`);
+    }
+    return result.value;
+}
 function parseCbu(value) {
     const normalizedValue = value.trim();
     if (!/^\d{22}$/.test(normalizedValue)) {
-        throw new Error(`El CBU "${value}" no es valido: debe tener 22 digitos.`);
+        throw new InputValidationError(`El CBU "${value}" no es válido: debe tener 22 digitos.`);
     }
     return normalizedValue;
 }
 function parseCbuAlias(value) {
     const normalizedValue = value.trim();
     if (!/^[A-Za-z0-9.-]{6,20}$/.test(normalizedValue)) {
-        throw new Error(`El alias "${value}" no es valido: debe tener entre 6 y 20 letras, numeros, puntos o guiones.`);
+        throw new InputValidationError(`El alias "${value}" no es válido: debe tener entre 6 y 20 letras, números, puntos o guiones.`);
     }
     return normalizedValue;
 }
 function parsePositiveInteger(value) {
-    const parsedValue = Number.parseInt(value.trim(), 10);
-    if (!Number.isInteger(parsedValue) || parsedValue <= 0) {
-        throw new Error(`El valor "${value}" no es un entero positivo valido.`);
+    const parsedValue = parseStrictInteger(value);
+    if (parsedValue === undefined || parsedValue <= 0) {
+        throw new InputValidationError(`El valor "${value}" no es un entero positivo válido.`);
     }
     return parsedValue;
 }
 function parseRecentCount(value) {
-    const parsedValue = Number(value.trim());
-    if (!Number.isInteger(parsedValue) || parsedValue < 1 || parsedValue > MAX_RECENT_VOUCHERS) {
-        throw new Error(`La cantidad "${value}" no es valida: tiene que ser un numero entre 1 y ${MAX_RECENT_VOUCHERS}.`);
+    const parsedValue = parseStrictInteger(value);
+    if (parsedValue === undefined || parsedValue < 1 || parsedValue > MAX_RECENT_VOUCHERS) {
+        throw new InputValidationError(`La cantidad "${value}" no es válida: tiene que ser un número entre 1 y ${MAX_RECENT_VOUCHERS}.`);
     }
     return parsedValue;
 }
 function parseExchangeRate(value) {
     const result = parseArgentineAmount(value, { maxDecimals: EXCHANGE_RATE_DECIMALS });
     if (!result.ok) {
-        throw new Error(`La cotizacion "${value}" no es valida: ${result.reason}.`);
+        throw new InputValidationError(`La cotización "${value}" no es válida: ${result.reason}.`);
     }
     return result.value;
 }
@@ -74,21 +84,21 @@ function parsePemPath(value, label) {
 // La fecha de inicio de actividades es vieja: se pide con anio para no completarla con el actual.
 function parseFullDate(value) {
     if (!/^\d{1,2}([-/])\d{1,2}\1(\d{2}|\d{4})$/.test(value.trim())) {
-        throw new Error(`La fecha "${value}" no es valida. Use D/MM/YYYY, por ejemplo 1/03/2020.`);
+        throw new InputValidationError(`La fecha "${value}" no es válida. Usá D/MM/YYYY, por ejemplo 1/03/2020.`);
     }
     return parseArgentineDateInputAsArcaDate(value);
 }
 function parseExistingFile(value, label) {
     const path = resolve(parseNonEmptyString(value));
     if (!existsSync(path)) {
-        throw new Error(`No se encontro ${label} en "${path}".`);
+        throw new InputValidationError(`No se encontró ${label} en "${path}".`);
     }
     return path;
 }
 function parseLogoPath(value) {
     const path = parseExistingFile(value, 'el logo');
     if (!/\.(png|jpe?g)$/i.test(path)) {
-        throw new Error('El logo debe ser un archivo PNG o JPG.');
+        throw new InputValidationError('El logo debe ser un archivo PNG o JPG.');
     }
     return path;
 }
@@ -107,7 +117,7 @@ export function parseConfigValue(key, value) {
         case 'cotizacionPorDefecto':
             return parseExchangeRate(value);
         case 'cuit':
-            return value.trim();
+            return parseConfigCuit(value);
         case 'emisor.condicionIva':
             return arcliDefaultIvaConditionSchema.parse(value.trim().toLowerCase());
         case 'emisor.domicilio':
@@ -125,6 +135,7 @@ export function parseConfigValue(key, value) {
         case 'monedaPorDefecto':
             return value.trim().toUpperCase();
         case 'verificarFce':
+        case 'consultarPadron':
         case 'output.emitirPorDefecto':
         case 'output.jsonPorDefecto':
         case 'output.brutoPorDefecto':
@@ -136,17 +147,21 @@ export function parseConfigValue(key, value) {
         case 'pdfNavegador':
             return parseExistingFile(value, 'el navegador');
         case 'puntoVentaPorDefecto':
+        case 'exportacion.actividad':
             return parsePositiveInteger(value);
         case 'ticketPath':
             return resolve(parseNonEmptyString(value));
         case 'cert.produccion':
         case 'cert.testing':
+        case 'exportacion.cert.produccion':
+        case 'exportacion.cert.testing':
             return parsePemPath(value, 'certificado');
         case 'key.produccion':
         case 'key.testing':
+        case 'exportacion.key.produccion':
+        case 'exportacion.key.testing':
             return parsePemPath(value, 'clave privada');
         default:
             return parseNonEmptyString(value);
     }
 }
-//# sourceMappingURL=config-value-parser.js.map

package/dist/modules/config/config.export-credentials.js

@@ -0,0 +1,23 @@
+import { ConfigurationError } from '../../lib/errors/app-error.js';
+/**
+ * WSFEX exige un certificado autorizado al servicio `wsfex`, que en general no es el mismo que el de wsfe.
+ * `exportacion.cert`/`exportacion.key` son opcionales: sin ellos se usan los certificados generales.
+ */
+export function resolveExportCredentials(config, environment) {
+    const dedicatedCert = config.exportacion?.cert[environment];
+    const dedicatedKey = config.exportacion?.key[environment];
+    if (Boolean(dedicatedCert) !== Boolean(dedicatedKey)) {
+        throw new ConfigurationError(`Para WSFEX en ${environment} configurá el certificado y la clave juntos.`, { faltan: dedicatedCert ? [`exportacion.key.${environment}`] : [`exportacion.cert.${environment}`] }, `Cargalos con "arcli config establecer exportacion.cert.${environment} <ruta>" y "arcli config establecer exportacion.key.${environment} <ruta>".`);
+    }
+    const cert = dedicatedCert ?? config.cert[environment];
+    const key = dedicatedKey ?? config.key[environment];
+    if (!cert || !key) {
+        throw new ConfigurationError(`Falta el certificado de WSFEX para ${environment}.`, {
+            faltan: [
+                ...(cert ? [] : [`exportacion.cert.${environment}`]),
+                ...(key ? [] : [`exportacion.key.${environment}`]),
+            ],
+        }, `Autorizá un certificado al servicio wsfex y cargalo con "arcli config establecer exportacion.cert.${environment} <ruta>" y "arcli config establecer exportacion.key.${environment} <ruta>".`);
+    }
+    return { cert, dedicated: Boolean(dedicatedCert), key };
+}

package/dist/modules/config/config.presenter.js

@@ -4,6 +4,7 @@ import { colorize, keyValuePanel, resolveKeyValueLabelWidth, statusPanel, toneTe
 import { RECENT_VOUCHERS_LIMIT } from '../vouchers/voucher-history.js';
 import { CONFIG_LABELS, CONFIG_SECTIONS } from './config.sections.js';
 function toPublicSnapshot(config, paths) {
+    const dedicated = config.exportacion;
     return {
         alicuota: config.alicuotaPorDefecto,
         aliasCbu: config.aliasCbu,
@@ -19,6 +20,17 @@ function toPublicSnapshot(config, paths) {
         emisor: { ...config.emisor, logo: config.emisor.logo ? maskPath(config.emisor.logo) : undefined },
         emitir: config.output.emitirPorDefecto,
         entorno: config.entornoPorDefecto,
+        exportacion: {
+            actividad: dedicated?.actividad,
+            cert: {
+                produccion: dedicated?.cert.produccion ? maskPath(dedicated.cert.produccion) : undefined,
+                testing: dedicated?.cert.testing ? maskPath(dedicated.cert.testing) : undefined,
+            },
+            key: {
+                produccion: dedicated?.key.produccion ? maskPath(dedicated.key.produccion) : undefined,
+                testing: dedicated?.key.testing ? maskPath(dedicated.key.testing) : undefined,
+            },
+        },
         ivaReceptor: config.ivaReceptorPorDefecto,
         json: config.output.jsonPorDefecto,
         key: {
@@ -33,6 +45,7 @@ function toPublicSnapshot(config, paths) {
         bruto: config.output.brutoPorDefecto,
         ticketPath: maskPath(paths.ticketPath),
         verificarFce: config.verificarFce,
+        consultarPadron: config.consultarPadron ?? true,
     };
 }
 export function formatConfig(config, paths) {
@@ -41,6 +54,10 @@ export function formatConfig(config, paths) {
 export function formatConfigPath(configPath) {
     return configPath;
 }
+/** `{ "ruta": "..." }`, como `ruta` en el JSON de `pdf desinstalar`. */
+export function formatConfigPathAsJson(configPath) {
+    return JSON.stringify({ ruta: configPath }, null, 2);
+}
 const NOT_SET = 'no configurado';
 const notSet = (value) => value ?? NOT_SET;
 const yesNo = (value) => (value ? 'si' : 'no');
@@ -56,7 +73,7 @@ const CONFIG_TEXT_VALUES = {
     concepto: (c) => notSet(c.concepto),
     cotizacion: (c) => c.cotizacion ?? 1,
     cuit: (c) => notSet(c.cuit),
-    'emisor.condicionIva': (c) => c.emisor.condicionIva ?? 'segun la letra',
+    'emisor.condicionIva': (c) => c.emisor.condicionIva ?? 'según la letra',
     'emisor.domicilio': (c) => notSet(c.emisor.domicilio),
     'emisor.iibb': (c) => notSet(c.emisor.iibb),
     'emisor.inicioActividades': (c) => c.emisor.inicioActividades ? formatArcaDateAsArgentineDate(c.emisor.inicioActividades) : NOT_SET,
@@ -64,6 +81,11 @@ const CONFIG_TEXT_VALUES = {
     'emisor.razonSocial': (c) => notSet(c.emisor.razonSocial),
     emitir: (c) => yesNo(c.emitir),
     entorno: (c) => c.entorno,
+    'exportacion.actividad': (c) => notSet(c.exportacion.actividad),
+    'exportacion.cert.produccion': (c) => notSet(c.exportacion.cert.produccion),
+    'exportacion.cert.testing': (c) => notSet(c.exportacion.cert.testing),
+    'exportacion.key.produccion': (c) => notSet(c.exportacion.key.produccion),
+    'exportacion.key.testing': (c) => notSet(c.exportacion.key.testing),
     ivaReceptor: (c) => notSet(c.ivaReceptor),
     json: (c) => yesNo(c.json),
     'key.produccion': (c) => notSet(c.key.produccion),
@@ -75,6 +97,7 @@ const CONFIG_TEXT_VALUES = {
     puntoVenta: (c) => notSet(c.puntoVenta),
     ticketPath: (c) => c.ticketPath,
     verificarFce: (c) => yesNo(c.verificarFce),
+    consultarPadron: (c) => yesNo(c.consultarPadron ?? true),
 };
 /**
  * La configuracion por secciones, en el mismo orden que "Modificar configuracion" del modo interactivo.
@@ -95,7 +118,7 @@ export function formatConfigAsText(config, paths) {
         // Los datos van corridos bajo el titulo, asi la seccion se lee aun sin color (NO_COLOR, pipes).
         ...section.rows.map(([label, value]) => `  ${colorize(label.padEnd(labelWidth), 'muted')}${gap}${value === NOT_SET ? colorize(value, 'muted') : value}`),
     ]);
-    return keyValuePanel('Configuracion', lines, undefined, 'standard', undefined, 'sheet');
+    return keyValuePanel('Configuración', lines, undefined, 'standard', undefined, 'sheet');
 }
 export function formatConfigDoctor(report) {
     return JSON.stringify({
@@ -118,10 +141,9 @@ export function formatConfigDoctorAsText(report) {
     });
     const tone = report.ok ? 'success' : report.checks.some((check) => check.category === 'error') ? 'danger' : 'warning';
     const footer = report.ok
-        ? 'Configuracion lista para usar ARCLI'
+        ? 'Configuración lista para usar ARCLI'
         : report.checks.some((check) => check.category === 'error')
             ? 'Hay puntos criticos por corregir antes de emitir'
-            : 'Revise las recomendaciones antes de emitir en serio';
-    return statusPanel('Revision de configuracion', lines, footer, 'wide', tone, 'checklist');
+            : 'Revisá las recomendaciones antes de emitir en serio';
+    return statusPanel('Revisión de configuración', lines, footer, 'wide', tone, 'checklist');
 }
-//# sourceMappingURL=config.presenter.js.map