arca-siradig 1.0.0

package/dist/src/cli/render.js

@@ -0,0 +1,262 @@
+export function printFormSummary(summary) {
+    console.log(renderFormSummary(summary, {
+        color: Boolean(process.stdout.isTTY) && !process.env.NO_COLOR,
+        width: process.stdout.columns,
+    }));
+}
+export function renderFormSummary(summary, options = {}) {
+    const width = Math.max(36, Math.min(options.width ?? 90, 110));
+    const lines = [];
+    const styled = (text, code) => options.color ? `\u001b[${code}m${text}\u001b[0m` : text;
+    const append = (text, indent = 0, style) => {
+        for (const line of wrapText(text, width - indent)) {
+            lines.push(`${" ".repeat(indent)}${style ? styled(line, style) : line}`);
+        }
+    };
+    const amountRow = (label, amount, indent = 0, style) => {
+        const money = `$ ${amount}`;
+        const labelWidth = Math.max(10, width - indent - money.length - 2);
+        const wrapped = wrapText(label, labelWidth);
+        for (const line of wrapped.slice(0, -1))
+            append(line, indent, style);
+        const last = wrapped.at(-1) ?? "";
+        lines.push(`${" ".repeat(indent)}${style ? styled(last.padEnd(labelWidth), style) : last.padEnd(labelWidth)}  ${styled(money, style ?? "38;5;151")}`);
+    };
+    lines.push("");
+    append(`F572 WEB · ${summary.period}`, 0, "1");
+    append(`Vista previa · Borrador${summary.submissionType ? ` · ${summary.submissionType}` : ""}`, 0, "90");
+    lines.push("─".repeat(width));
+    append(summary.person.name, 0, "1");
+    append(`CUIT ${summary.person.id}`, 0, "90");
+    if (summary.withholdingAgent) {
+        lines.push("");
+        append("Agente de retención", 0, "90");
+        append(summary.withholdingAgent.name);
+        append(`CUIT ${summary.withholdingAgent.id}`, 0, "90");
+    }
+    lines.push("");
+    append("TOTALES INFORMADOS POR ARCA", 0, "1");
+    for (const total of summary.totals)
+        amountRow(total.label, total.amount);
+    const emptySections = [];
+    for (const section of summary.sections) {
+        const title = shortFormSectionTitle(section.title);
+        if (!section.hasData) {
+            emptySections.push(title);
+            continue;
+        }
+        lines.push("");
+        append(title.toUpperCase(), 0, "1");
+        lines.push(styled("─".repeat(width), "90"));
+        for (const table of section.tables) {
+            const isMoneyTable = table.some((row) => /Subtotal\s*:|Importe Total\s*:|\$/i.test(row[1] ?? ""));
+            if (!isMoneyTable) {
+                const headers = table[0] ?? [];
+                for (const row of table.slice(1)) {
+                    for (const [index, value] of row.entries()) {
+                        if (value)
+                            append(headers[index] ? `${headers[index]}: ${value}` : value, 2);
+                    }
+                    lines.push("");
+                }
+                continue;
+            }
+            for (const row of table) {
+                if (/Importe Total\s*:/i.test(row[1] ?? ""))
+                    continue;
+                if (/Subtotal\s*:/i.test(row[1] ?? "")) {
+                    const provider = row[0].match(/^(\d{11})\s*-\s*(.+)$/);
+                    lines.push("");
+                    if (provider) {
+                        append(provider[2], 2);
+                        amountRow(`Subtotal · CUIT ${provider[1]}`, row[2], 2, "90");
+                    }
+                    else {
+                        amountRow(row[0], row[2], 0, "1");
+                    }
+                }
+                else if (row[1]?.includes("$") && row.length >= 3) {
+                    const label = row.length >= 5 ? `${row[0]} (${row[1].replace(/x/i, "×")} ${row[2]})` : row[0];
+                    amountRow(label, row.at(-1) ?? "", 4);
+                }
+                else {
+                    append(row.filter(Boolean).join(" · "), 2);
+                }
+            }
+        }
+    }
+    if (emptySections.length) {
+        lines.push("");
+        append("Sin datos informados", 0, "90");
+        append(emptySections.join(" · "), 2, "90");
+    }
+    return lines.join("\n");
+}
+function shortFormSectionTitle(title) {
+    if (/^1\s*-/.test(title))
+        return "Cargas de familia";
+    if (/^2\s*-/.test(title))
+        return "Otros empleadores";
+    if (/^3\s*-/.test(title))
+        return "Deducciones y desgravaciones";
+    if (/^4\s*-/.test(title))
+        return "Retenciones, percepciones y pagos a cuenta";
+    if (/^5\s*-/.test(title))
+        return "Beneficios";
+    return title;
+}
+function wrapText(text, width) {
+    const lines = [];
+    let line = "";
+    for (const word of text.split(/\s+/).filter(Boolean)) {
+        if (line && line.length + word.length + 1 > width) {
+            lines.push(line);
+            line = "";
+        }
+        if (word.length > width) {
+            if (line)
+                lines.push(line);
+            for (let index = 0; index < word.length - width; index += width)
+                lines.push(word.slice(index, index + width));
+            line = word.slice(Math.floor((word.length - 1) / width) * width);
+        }
+        else {
+            line += `${line ? " " : ""}${word}`;
+        }
+    }
+    if (line || !lines.length)
+        lines.push(line);
+    return lines;
+}
+export function printPersonalData(groups) {
+    printDataGroups("Datos Personales", groups, "No se encontraron datos personales para mostrar.");
+}
+export function printEmployees(employees) {
+    console.log("\nEmpleadores");
+    if (employees.length === 0) {
+        console.log("No se encontraron empleadores para mostrar.");
+        return;
+    }
+    employees.forEach((employee, index) => {
+        if (index > 0) {
+            console.log("");
+        }
+        console.log(`CUIT: ${employee.cuit}`);
+        console.log(`Razón Social / Apellido y Nombre: ${employee.name}`);
+        console.log(`Fecha Inicio: ${employee.startDate ?? ""}`);
+        console.log(`Fecha Fin: ${employee.endDate ?? ""}`);
+        console.log(`Agente de Retención: ${employee.withholdingAgent ?? ""}`);
+    });
+}
+export function printEmployeeData(groups) {
+    printDataGroups("Empleador", groups, "No se encontraron datos del empleador para mostrar.", {
+        skipFirstGroupTitleIfMatchesHeading: true,
+    });
+}
+export function printDeductions(deductions) {
+    console.log("\nDeducciones y desgravaciones");
+    if (deductions.length === 0) {
+        console.log("No se encontraron deducciones para mostrar.");
+        return;
+    }
+    deductions.forEach((deduction, index) => {
+        if (index > 0) {
+            console.log("");
+        }
+        console.log(`Type: ${deduction.type}`);
+        console.log(`ID: ${deduction.id}`);
+        console.log(`CUIT: ${deduction.cuit}`);
+        console.log(`Denominación: ${deduction.name}`);
+        console.log(`Período: ${deduction.period}`);
+        console.log(`Importe: ${deduction.amount}`);
+    });
+}
+export function printReceiptTypes(receiptTypes) {
+    console.log("ID      Tipo");
+    for (const receiptType of receiptTypes) {
+        console.log(`${receiptType.id.padEnd(7)} ${receiptType.name}`);
+    }
+}
+export function printDeductionDetail(detail) {
+    console.log(`\n${detail.heading}`);
+    console.log(`CUIT: ${detail.cuit}`);
+    console.log(`Razón Social: ${detail.name}`);
+    console.log("");
+    if (isSinglePeriodDeduction(detail)) {
+        printSectionTitle("Período y Monto");
+        console.log(`Período: ${detail.fromMonthLabel}`);
+        console.log(`Monto Deducible: ${detail.amount}`);
+    }
+    else {
+        printSectionTitle("Período");
+        console.log(`Mes Desde: ${detail.fromMonthLabel}`);
+        console.log(`Mes Hasta: ${detail.toMonthLabel}`);
+        console.log("");
+        printSectionTitle("Monto");
+        console.log(`Monto Total: ${detail.amount}`);
+    }
+    if (detail.monthlyDetail.length > 0) {
+        console.log("");
+        printSectionTitle("Detalle Mensual");
+        for (const monthlyDetail of detail.monthlyDetail) {
+            console.log(`Mes: ${formatMonthName(monthlyDetail.month)}`);
+            console.log(`Monto Mensual: ${monthlyDetail.monthlyAmount}`);
+            console.log(`Monto Comprobantes Ingresados: ${monthlyDetail.receiptsTotalAmount}`);
+            console.log("");
+        }
+    }
+    if (detail.receipts.length > 0) {
+        if (detail.monthlyDetail.length === 0) {
+            console.log("");
+        }
+        printSectionTitle("Comprobantes");
+        for (const receipt of detail.receipts) {
+            console.log(`Mes: ${formatMonthName(receipt.month)}`);
+            console.log(`Fecha: ${receipt.date}`);
+            console.log(`Tipo: ${receipt.type}`);
+            console.log(`ID: ${receipt.id}`);
+            console.log(`Monto: ${receipt.amount}`);
+            console.log("");
+        }
+    }
+}
+function printSectionTitle(title) {
+    console.log(title);
+    console.log("-".repeat(title.length));
+}
+function isSinglePeriodDeduction(detail) {
+    return detail.monthlyDetail.length === 0 && detail.fromMonth > 0 && detail.toMonth === 0;
+}
+function printDataGroups(title, groups, emptyMessage, options = {}) {
+    console.log(`\n${title}`);
+    if (groups.length === 0) {
+        console.log(emptyMessage);
+        return;
+    }
+    groups.forEach((group, index) => {
+        const shouldSkipGroupTitle = options.skipFirstGroupTitleIfMatchesHeading && index === 0 && group.title === title;
+        if (!shouldSkipGroupTitle) {
+            console.log(`\n${group.title}`);
+        }
+        for (const field of group.fields) {
+            console.log(`- ${field.label}: ${field.value}`);
+        }
+    });
+}
+function formatMonthName(month) {
+    const monthNames = [
+        "Enero",
+        "Febrero",
+        "Marzo",
+        "Abril",
+        "Mayo",
+        "Junio",
+        "Julio",
+        "Agosto",
+        "Septiembre",
+        "Octubre",
+        "Noviembre",
+        "Diciembre",
+    ];
+    return monthNames[month - 1] ?? String(month);
+}

package/dist/src/cli/structured-output.d.ts

@@ -0,0 +1,4 @@
+import type { DataGroup, DeductionDetailView, StructuredDeductionDetail, StructuredEmployeeData, StructuredPersonalData } from "../types.js";
+export declare function toStructuredPersonalData(groups: DataGroup[]): StructuredPersonalData[];
+export declare function toStructuredEmployeeData(groups: DataGroup[]): StructuredEmployeeData[];
+export declare function toStructuredDeductionDetail(detail: DeductionDetailView): StructuredDeductionDetail;

package/dist/src/cli/structured-output.js

@@ -0,0 +1,92 @@
+const personalDataFieldMap = {
+    Apellido: "lastName",
+    Nombre: "firstName",
+    Calle: "street",
+    "Nro.": "streetNumber",
+    Provincia: "province",
+    "Código Postal": "zipCode",
+};
+const employeeDataFieldMap = {
+    "CUIT del Empleador": "cuit",
+    "Razón Social o Apellido y Nombre": "name",
+    "Fecha de Inicio de Relación": "startDate",
+    "Fecha de Fin de Relación": "endDate",
+    "¿Es su agente de retención?": "retentionAgent",
+};
+export function toStructuredPersonalData(groups) {
+    const record = {};
+    for (const group of groups) {
+        for (const field of group.fields) {
+            const key = personalDataFieldMap[field.label];
+            if (!key || !field.value) {
+                continue;
+            }
+            record[key] = field.value;
+        }
+    }
+    return Object.keys(record).length > 0 ? [record] : [];
+}
+export function toStructuredEmployeeData(groups) {
+    const record = {};
+    for (const group of groups) {
+        for (const field of group.fields) {
+            const key = employeeDataFieldMap[field.label];
+            if (!key || !field.value) {
+                continue;
+            }
+            if (key === "startDate" || key === "endDate") {
+                const normalizedDate = normalizeArcaDate(field.value);
+                if (normalizedDate) {
+                    record[key] = normalizedDate;
+                }
+                continue;
+            }
+            if (key === "retentionAgent") {
+                const retentionAgent = normalizeRetentionAgent(field.value);
+                if (retentionAgent !== null) {
+                    record.retentionAgent = retentionAgent;
+                }
+                continue;
+            }
+            record[key] = field.value;
+        }
+    }
+    return Object.keys(record).length > 0 ? [record] : [];
+}
+export function toStructuredDeductionDetail(detail) {
+    return {
+        cuit: detail.cuit,
+        name: detail.name,
+        fromMonth: detail.fromMonth,
+        toMonth: detail.toMonth,
+        amount: detail.amount,
+        monthlyDetail: detail.monthlyDetail,
+        receipts: detail.receipts.map(toStructuredDeductionReceipt),
+    };
+}
+function toStructuredDeductionReceipt(receipt) {
+    return {
+        month: receipt.month,
+        date: receipt.date,
+        type: receipt.typeId,
+        id: receipt.id,
+        amount: receipt.amount,
+    };
+}
+function normalizeArcaDate(value) {
+    const match = value.trim().match(/^(\d{2})\/(\d{2})\/(\d{4})$/);
+    if (!match) {
+        return null;
+    }
+    const [, day, month, year] = match;
+    return `${year}-${month}-${day}`;
+}
+function normalizeRetentionAgent(value) {
+    if (value === "Sí" || value === "Si") {
+        return true;
+    }
+    if (value === "No") {
+        return false;
+    }
+    return null;
+}

package/dist/src/files/pdf.d.ts

@@ -0,0 +1,3 @@
+export declare function resolvePdfDestination(path: string, defaultFilename: string): Promise<string>;
+/** Uses exclusive creation so simultaneous downloads never overwrite one another. */
+export declare function savePdfWithUniqueName(body: Buffer, destination: string): Promise<string>;

package/dist/src/files/pdf.js

@@ -0,0 +1,43 @@
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve } from "node:path";
+export async function resolvePdfDestination(path, defaultFilename) {
+    if (!path.trim() || path.includes("\0")) {
+        throw new Error("--path debe indicar una carpeta o un nombre de archivo .pdf.");
+    }
+    const absolutePath = resolve(path);
+    const info = await stat(absolutePath).catch((error) => {
+        if (hasErrorCode(error, "ENOENT"))
+            return null;
+        throw error;
+    });
+    if (info && !info.isDirectory() && /[\\/]$/.test(path)) {
+        throw new Error(`La ruta ${absolutePath} es un archivo. Indicá una carpeta o quitá la barra final.`);
+    }
+    const isDirectory = info?.isDirectory() || /[\\/]$/.test(path) || (!info && !extname(path));
+    const destination = isDirectory ? join(absolutePath, defaultFilename) : absolutePath;
+    if (extname(destination).toLowerCase() !== ".pdf") {
+        throw new Error("--path debe ser una carpeta o un archivo con extensión .pdf, por ejemplo ./f572.pdf.");
+    }
+    await mkdir(dirname(destination), { recursive: true });
+    return destination;
+}
+/** Uses exclusive creation so simultaneous downloads never overwrite one another. */
+export async function savePdfWithUniqueName(body, destination) {
+    const extension = extname(destination);
+    const stem = basename(destination, extension);
+    for (let index = 0;; index += 1) {
+        const filename = index === 0 ? `${stem}${extension}` : `${stem} (${index})${extension}`;
+        const path = join(dirname(destination), filename);
+        try {
+            await writeFile(path, body, { flag: "wx", mode: 0o600 });
+            return path;
+        }
+        catch (error) {
+            if (!hasErrorCode(error, "EEXIST"))
+                throw error;
+        }
+    }
+}
+function hasErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

package/dist/src/files/private.d.ts

@@ -0,0 +1,4 @@
+export declare function ensurePrivateDirectory(path: string): Promise<void>;
+export declare function writePrivateFile(path: string, body: string | Uint8Array): Promise<void>;
+/** Replaces existing files atomically, including their previous permissions. */
+export declare function atomicWritePrivateFile(path: string, body: string | Uint8Array): Promise<void>;

package/dist/src/files/private.js

@@ -0,0 +1,21 @@
+import { randomUUID } from "node:crypto";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+export async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    await chmod(path, 0o700);
+}
+export async function writePrivateFile(path, body) {
+    await writeFile(path, body, { flag: "wx", mode: 0o600 });
+}
+/** Replaces existing files atomically, including their previous permissions. */
+export async function atomicWritePrivateFile(path, body) {
+    const temporaryPath = join(dirname(path), `.${basename(path)}.${randomUUID()}.tmp`);
+    try {
+        await writePrivateFile(temporaryPath, body);
+        await rename(temporaryPath, path);
+    }
+    finally {
+        await rm(temporaryPath, { force: true });
+    }
+}

package/dist/src/security/errors.d.ts

@@ -0,0 +1,2 @@
+/** Redacts literal, JSON-escaped, and URL-encoded secrets from error diagnostics. */
+export declare function safeErrorMessage(error: unknown, secrets?: readonly (string | undefined)[]): string;

package/dist/src/security/errors.js

@@ -0,0 +1,22 @@
+/** Redacts literal, JSON-escaped, and URL-encoded secrets from error diagnostics. */
+export function safeErrorMessage(error, secrets = []) {
+    let message = error instanceof Error ? error.message : String(error);
+    const variants = new Set();
+    for (const secret of secrets) {
+        if (!secret)
+            continue;
+        variants.add(secret);
+        variants.add(JSON.stringify(secret).slice(1, -1));
+        // A malformed surrogate must not break error reporting.
+        try {
+            variants.add(encodeURIComponent(secret));
+        }
+        catch {
+            // The literal and JSON forms still cover browser call logs.
+        }
+    }
+    for (const secret of [...variants].sort((a, b) => b.length - a.length)) {
+        message = message.replaceAll(secret, "[REDACTED]");
+    }
+    return message;
+}

package/dist/src/session/store.d.ts

@@ -0,0 +1,15 @@
+import type { BrowserContextOptions } from "playwright";
+import type { SelectedPerson } from "../types.js";
+export type StoredSession = {
+    cuit: string;
+    createdAt: string;
+    selectedPerson?: SelectedPerson | null;
+    storageState: NonNullable<BrowserContextOptions["storageState"]>;
+};
+export type SessionStore = {
+    read: () => Promise<StoredSession | null>;
+    write: (session: StoredSession) => Promise<void>;
+    clear: () => Promise<void>;
+    path: string;
+};
+export declare function createSessionStore(baseDir?: string): SessionStore;

package/dist/src/session/store.js

@@ -0,0 +1,35 @@
+import { chmod, readFile, rm } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { atomicWritePrivateFile, ensurePrivateDirectory } from "../files/private.js";
+export function createSessionStore(baseDir = join(homedir(), ".arca-siradig")) {
+    const path = join(baseDir, "session.json");
+    return {
+        path,
+        read: async () => {
+            try {
+                await chmod(baseDir, 0o700);
+                await chmod(path, 0o600);
+                const content = await readFile(path, "utf8");
+                return JSON.parse(content);
+            }
+            catch (error) {
+                if (isMissingFileError(error)) {
+                    return null;
+                }
+                throw error;
+            }
+        },
+        write: async (session) => {
+            await ensurePrivateDirectory(baseDir);
+            const { cuit, createdAt, selectedPerson, storageState } = session;
+            await atomicWritePrivateFile(path, `${JSON.stringify({ cuit, createdAt, selectedPerson, storageState }, null, 2)}\n`);
+        },
+        clear: async () => {
+            await rm(path, { force: true });
+        },
+    };
+}
+function isMissingFileError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/src/types.d.ts

@@ -0,0 +1,106 @@
+export type ArcaCredentials = {
+    cuit: string;
+    password: string;
+};
+export type ArcaSession = {
+    close: () => Promise<void>;
+};
+export type Person = {
+    id: string | null;
+    name: string;
+};
+export type SelectedPerson = Person;
+export type MenuItem = {
+    label: string;
+    enabled: boolean;
+};
+export type ReminderModalInfo = {
+    title: string;
+    description: string;
+};
+export type DataField = {
+    label: string;
+    value: string;
+};
+export type DataGroup = {
+    title: string;
+    fields: DataField[];
+};
+export type PersonalDataField = DataField;
+export type PersonalDataGroup = DataGroup;
+export type EmployeeSummary = {
+    id: string;
+    cuit: string;
+    name: string;
+    startDate: string | null;
+    endDate: string | null;
+    withholdingAgent: string | null;
+};
+export type StructuredPersonalData = {
+    lastName?: string;
+    firstName?: string;
+    street?: string;
+    streetNumber?: string;
+    province?: string;
+    zipCode?: string;
+};
+export type StructuredEmployeeData = {
+    cuit?: string;
+    name?: string;
+    startDate?: string;
+    endDate?: string;
+    retentionAgent?: boolean;
+};
+export type ReceiptType = {
+    id: string;
+    name: string;
+};
+export type DeductionSummary = {
+    type: string;
+    id: string;
+    cuit: string;
+    name: string;
+    period: string;
+    amount: string;
+};
+export type DeductionMonthlyDetail = {
+    month: number;
+    monthlyAmount: string;
+    receiptsTotalAmount: string;
+};
+export type DeductionReceipt = {
+    month: number;
+    date: string;
+    typeId: string;
+    type: string;
+    id: string;
+    amount: string;
+};
+export type StructuredDeductionReceipt = {
+    month: number;
+    date: string;
+    type: string;
+    id: string;
+    amount: string;
+};
+export type DeductionDetailView = {
+    heading: string;
+    cuit: string;
+    name: string;
+    fromMonth: number;
+    fromMonthLabel: string;
+    toMonth: number;
+    toMonthLabel: string;
+    amount: string;
+    monthlyDetail: DeductionMonthlyDetail[];
+    receipts: DeductionReceipt[];
+};
+export type StructuredDeductionDetail = {
+    cuit: string;
+    name: string;
+    fromMonth: number;
+    toMonth: number;
+    amount: string;
+    monthlyDetail: DeductionMonthlyDetail[];
+    receipts: StructuredDeductionReceipt[];
+};

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "arca-siradig",
+  "version": "1.0.0",
+  "description": "CLI to inspect, update, print and submit ARCA SiRADIG Form 572 drafts.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jpgarcia/arca-siradig.git"
+  },
+  "homepage": "https://github.com/jpgarcia/arca-siradig#readme",
+  "bugs": {
+    "url": "https://github.com/jpgarcia/arca-siradig/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "bin": {
+    "arca-siradig": "./dist/src/cli/index.js"
+  },
+  "files": [
+    "dist/src/**/*.js",
+    "dist/src/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": "^20.17.0 || ^22.13.0 || >=23.5.0"
+  },
+  "scripts": {
+    "arca-siradig": "tsx src/cli/index.ts",
+    "build": "node scripts/build.mjs",
+    "prepack": "npm run build",
+    "check": "biome check .",
+    "format": "biome format --write .",
+    "test": "playwright test"
+  },
+  "keywords": [
+    "arca",
+    "afip",
+    "siradig",
+    "cli",
+    "playwright"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "^2.5.0",
+    "@playwright/test": "^1.61.0",
+    "@types/node": "^25.9.3",
+    "tsx": "^4.22.4",
+    "typescript": "^6.0.3"
+  },
+  "dependencies": {
+    "@inquirer/prompts": "^8.5.2",
+    "dotenv": "^17.4.2",
+    "playwright": "^1.61.0"
+  }
+}