arca-siradig 1.0.0

package/dist/src/arca/receipt-types.js

@@ -0,0 +1,39 @@
+export const RECEIPT_TYPES = [
+    { id: "6", name: "Factura B" },
+    { id: "7", name: "Nota de Débito B" },
+    { id: "8", name: "Nota de Crédito B" },
+    { id: "9", name: "Recibo B" },
+    { id: "10", name: "Nota de Venta al contado B" },
+    { id: "11", name: "Factura C" },
+    { id: "12", name: "Nota de Débito C" },
+    { id: "13", name: "Nota de Crédito C" },
+    { id: "14", name: "Documento Aduanero" },
+    { id: "15", name: "Recibo C" },
+    { id: "16", name: "Nota de Venta al contado C" },
+    { id: "40", name: "Otro comprobante B (RG 1415)" },
+    { id: "41", name: "Otro comprobante C (RG 1415)" },
+    { id: "82", name: "Tique-factura B" },
+    { id: "88", name: "Otros comp. doc. exceptuados" },
+];
+export function listReceiptTypes() {
+    return RECEIPT_TYPES.map((receiptType) => ({ ...receiptType }));
+}
+export function resolveReceiptTypeId(label) {
+    const normalizedLabel = normalizeReceiptTypeLabel(label);
+    for (const receiptType of RECEIPT_TYPES) {
+        if (normalizeReceiptTypeLabel(receiptType.name) === normalizedLabel) {
+            return receiptType.id;
+        }
+    }
+    return RECEIPT_TYPE_LABEL_ALIASES[normalizedLabel] ?? null;
+}
+const RECEIPT_TYPE_LABEL_ALIASES = {
+    [normalizeReceiptTypeLabel("Otros comprobantes documentos exceptuados")]: "88",
+};
+function normalizeReceiptTypeLabel(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "");
+}

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

@@ -0,0 +1,27 @@
+import { type Browser, type BrowserContext, type BrowserContextOptions, type Page } from "playwright";
+import type { ArcaCredentials } from "../types.js";
+export declare const ARCA_LOGIN_URL = "https://auth.afip.gob.ar/contribuyente_/login.xhtml";
+export declare const SIRADIG_LOGIN_URL = "https://auth.afip.gob.ar/contribuyente_/login.xhtml?action=SYSTEM&system=radig";
+export declare const SIRADIG_BASE_URL = "https://serviciosjava2.afip.gob.ar/radig/";
+export declare const ARCA_PORTAL_URL = "https://portalcf.cloud.afip.gob.ar/portal/app/";
+export declare const ARCA_PORTAL_EXPIRED_SESSION_URL = "https://portalcf.cloud.afip.gob.ar/portal/app/expiredSession";
+export declare const SIRADIG_SERVICE_NAME = "SiRADIG - Trabajador";
+export type BrowserSession = {
+    browser: Browser;
+    context: BrowserContext;
+    page: Page;
+};
+export type BrowserSessionOptions = {
+    headless?: boolean;
+    storageState?: BrowserContextOptions["storageState"];
+};
+export declare class ArcaLoginError extends Error {
+    constructor(message: string);
+}
+export declare function createBrowserSession(options?: BrowserSessionOptions): Promise<BrowserSession>;
+export declare function closeBrowserSession(session: BrowserSession): Promise<void>;
+export declare function loginToArca(page: Page, credentials: ArcaCredentials): Promise<void>;
+export declare function openSiradigFromPortal(page: Page): Promise<Page>;
+export declare function recoverWorkerSiradigPage(page: Page, period?: number): Promise<void>;
+export declare function assertWorkerSiradigUrl(url: string): void;
+export declare function isExpiredPortalSessionUrl(url: string): boolean;

package/dist/src/arca/session.js

@@ -0,0 +1,165 @@
+import { chromium, } from "playwright";
+import { safeErrorMessage } from "../security/errors.js";
+export const ARCA_LOGIN_URL = "https://auth.afip.gob.ar/contribuyente_/login.xhtml";
+export const SIRADIG_LOGIN_URL = `${ARCA_LOGIN_URL}?action=SYSTEM&system=radig`;
+export const SIRADIG_BASE_URL = "https://serviciosjava2.afip.gob.ar/radig/";
+const SIRADIG_EMPLOYER_BASE_URL = "https://serviciosjava2.afip.gob.ar/radig_emp/";
+export const ARCA_PORTAL_URL = "https://portalcf.cloud.afip.gob.ar/portal/app/";
+export const ARCA_PORTAL_EXPIRED_SESSION_URL = `${ARCA_PORTAL_URL}expiredSession`;
+export const SIRADIG_SERVICE_NAME = "SiRADIG - Trabajador";
+export class ArcaLoginError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ArcaLoginError";
+    }
+}
+export async function createBrowserSession(options = {}) {
+    const browser = await chromium.launch({ headless: options.headless ?? false });
+    const context = await browser.newContext({ storageState: options.storageState });
+    const page = await context.newPage();
+    return { browser, context, page };
+}
+export async function closeBrowserSession(session) {
+    await session.context.close();
+    await session.browser.close();
+}
+export async function loginToArca(page, credentials) {
+    try {
+        await performLogin(page, credentials);
+    }
+    catch (error) {
+        const message = safeErrorMessage(error, [credentials.password, credentials.cuit]);
+        if (error instanceof ArcaLoginError)
+            throw new ArcaLoginError(message);
+        // Do not retain the original error or cause: Playwright may include fill values.
+        throw new Error(message);
+    }
+}
+async function performLogin(page, credentials) {
+    await page.goto(SIRADIG_LOGIN_URL, { waitUntil: "domcontentloaded" });
+    await page
+        .locator('[id="F1:username"], input[type="number"], input[role="spinbutton"]')
+        .first()
+        .fill(credentials.cuit);
+    await page.getByRole("button", { name: "Siguiente" }).click();
+    await waitForLoginOutcome(page, "password");
+    const cuitErrorMessage = await getLoginErrorMessage(page);
+    if (cuitErrorMessage) {
+        throw new ArcaLoginError(cuitErrorMessage);
+    }
+    const passwordInput = page.locator('input[type="password"]').first();
+    await passwordInput.waitFor({ state: "visible", timeout: 15_000 });
+    await passwordInput.fill(credentials.password);
+    await page.getByRole("button", { name: "Ingresar" }).click();
+    await waitForLoginOutcome(page, "authenticated");
+    const loginErrorMessage = await getLoginErrorMessage(page);
+    if (loginErrorMessage) {
+        throw new ArcaLoginError(loginErrorMessage);
+    }
+}
+export async function openSiradigFromPortal(page) {
+    await page.waitForLoadState("domcontentloaded").catch(() => undefined);
+    if (page.url().startsWith(SIRADIG_BASE_URL) || page.url().startsWith(SIRADIG_EMPLOYER_BASE_URL)) {
+        await recoverWorkerSiradigPage(page);
+        return page;
+    }
+    const portalLink = page
+        .getByText(/^\s*siradig\s*[-–—]?\s*trabajador\s*$/i)
+        .filter({ visible: true })
+        .first();
+    const viewAll = page
+        .getByText(/^ver todos$/i)
+        .filter({ visible: true })
+        .first();
+    try {
+        await portalLink.or(viewAll).first().waitFor({ state: "visible", timeout: 30_000 });
+        if (!(await portalLink.isVisible())) {
+            await viewAll.click();
+        }
+        await portalLink.waitFor({ state: "visible", timeout: 30_000 });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError") {
+            throw new Error('Ingresaste a ARCA, pero no se encontró el servicio SiRADIG - Trabajador visible en el portal. Ejecutá login con --headless false y revisá si aparece en "Mis servicios" o si hay un aviso pendiente.');
+        }
+        throw error;
+    }
+    const currentUrl = page.url();
+    const popupPromise = page.waitForEvent("popup", { timeout: 10_000 }).catch(() => null);
+    const samePageNavigationPromise = page
+        .waitForURL((url) => url.href !== currentUrl, { timeout: 10_000 })
+        .then(() => page)
+        .catch(() => null);
+    await portalLink.click();
+    const siradigPage = (await Promise.race([popupPromise, samePageNavigationPromise])) ?? page;
+    await siradigPage.waitForLoadState("domcontentloaded").catch(() => undefined);
+    await recoverWorkerSiradigPage(siradigPage);
+    return siradigPage;
+}
+export async function recoverWorkerSiradigPage(page, period = new Date().getFullYear()) {
+    if (!new URL(page.url()).pathname.startsWith("/radig_emp/"))
+        return;
+    const workerUrl = new URL("https://serviciosjava2.afip.gob.ar/radig/jsp/determinarContribuyente.do");
+    workerUrl.searchParams.set("codigo", String(period));
+    await page.goto(workerUrl.href, { waitUntil: "domcontentloaded" });
+    assertWorkerSiradigUrl(page.url());
+    try {
+        await page
+            .locator('#btn_datos_personales, form[name="seleccionaEmpresaForm"], input[type="button"].btn_empresa')
+            .first()
+            .waitFor({ state: "attached", timeout: 30_000 });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError") {
+            throw new Error("No se pudo abrir SiRADIG - Trabajador desde la sesión de Empleador. Revisá el acceso al servicio con --headless false.");
+        }
+        throw error;
+    }
+}
+export function assertWorkerSiradigUrl(url) {
+    if (new URL(url).pathname.startsWith("/radig_emp/")) {
+        throw new Error('Se abrió SiRADIG - Empleador (/radig_emp/). Este CLI requiere SiRADIG - Trabajador (/radig/). Volvé al portal y verificá que el servicio "SiRADIG - Trabajador" esté disponible en "Ver Todos".');
+    }
+}
+export function isExpiredPortalSessionUrl(url) {
+    return url.startsWith(ARCA_PORTAL_EXPIRED_SESSION_URL);
+}
+async function waitForLoginOutcome(page, stage) {
+    try {
+        await page.waitForFunction(({ stage, portalUrl, workerUrl, employerUrl }) => {
+            const hasError = Array.from(document.querySelectorAll('[id="F1:msg"], .text-danger')).some((element) => element.getClientRects().length > 0 && element.textContent?.trim());
+            if (hasError)
+                return true;
+            if (stage === "password") {
+                return Array.from(document.querySelectorAll('input[type="password"]')).some((element) => element.getClientRects().length > 0);
+            }
+            return (window.location.href.startsWith(portalUrl) ||
+                window.location.href.startsWith(workerUrl) ||
+                window.location.href.startsWith(employerUrl));
+        }, {
+            stage,
+            portalUrl: ARCA_PORTAL_URL,
+            workerUrl: SIRADIG_BASE_URL,
+            employerUrl: SIRADIG_EMPLOYER_BASE_URL,
+        }, { timeout: 30_000 });
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "TimeoutError") {
+            throw new ArcaLoginError(stage === "password"
+                ? "ARCA no mostró el campo de clave ni un mensaje de error después de enviar el CUIT/CUIL."
+                : "ARCA no confirmó el ingreso a SiRADIG o al portal. Revisá si requiere una verificación adicional con --headless false.");
+        }
+        throw error;
+    }
+}
+async function getLoginErrorMessage(page) {
+    const messages = page.locator('[id="F1:msg"], .text-danger');
+    for (const message of await messages.all()) {
+        if (!(await message.isVisible()))
+            continue;
+        const text = (await message.textContent())?.replace(/\s+/g, " ").trim();
+        if (text)
+            return text;
+    }
+    return null;
+}

package/dist/src/arca/submission.d.ts

@@ -0,0 +1,22 @@
+import type { Page } from "playwright";
+import { type FormContext } from "./form.js";
+export type FormSubmissionResult = FormContext & {
+    status: "submitted" | "cancelled" | "rejected" | "unconfirmed";
+    message: string;
+    reference?: string;
+    confirmationSource?: "acknowledgement" | "sent-forms";
+    submissionType?: string;
+    submittedAt?: string;
+    resultUrl?: string;
+};
+export declare function submitForm(page: Page, context: FormContext, options: {
+    accept: boolean;
+    confirm?: (message: string) => Promise<boolean>;
+    timeoutMs?: number;
+}): Promise<FormSubmissionResult>;
+export declare function openSubmissionConfirmation(page: Page, context: FormContext): Promise<string>;
+export declare function cancelSubmission(page: Page, context: FormContext): Promise<FormSubmissionResult>;
+/** The final click is attempted once. A timeout must never trigger another presentation. */
+export declare function generatePresentation(page: Page, context: FormContext, options?: {
+    timeoutMs?: number;
+}): Promise<FormSubmissionResult>;

package/dist/src/arca/submission.js

@@ -0,0 +1,140 @@
+import { verifyFormContext } from "./form.js";
+import { findNewSubmittedForm, readSubmittedForms } from "./submitted-forms.js";
+const SUCCESS_PATTERN = /(?:presentaci[oó]n|formulario)[^\n.]{0,80}(?:generad[oa]|enviad[oa]|presentad[oa])\s+(?:correctamente|con [eé]xito|exitosamente)/i;
+const ERROR_SELECTOR = ".text-danger, .formError, .ui-state-error";
+const NEGATIVE_PATTERN = /\bno(?:\s+(?:se|ha|sido|fue|pudo)){0,4}\s+(?:gener(?:ar|ad[oa])|envi(?:ar|ad[oa])|present(?:ar|ad[oa])|procesar|realizar)/i;
+export async function submitForm(page, context, options) {
+    if (!options.accept && !options.confirm)
+        throw new Error("Falta confirmar el envío del formulario.");
+    const message = await openSubmissionConfirmation(page, context);
+    const accepted = options.accept || (await options.confirm?.(message));
+    if (!accepted)
+        return cancelSubmission(page, context);
+    return generatePresentation(page, context, options);
+}
+export async function openSubmissionConfirmation(page, context) {
+    await verifyFormContext(page, { period: context.period, person: context.person.id });
+    await page.locator("#btn_enviar_empleador").click();
+    const dialog = submissionDialog(page);
+    try {
+        await dialog.waitFor({ state: "visible", timeout: 15_000 });
+    }
+    catch (error) {
+        const portalError = await readPortalError(page);
+        if (portalError)
+            throw new Error(`ARCA no permite enviar el formulario: ${portalError}`);
+        throw error;
+    }
+    return page.locator("#confirmacion_generacion_presentacion").innerText();
+}
+export async function cancelSubmission(page, context) {
+    await submissionDialog(page).getByRole("button", { name: "Cancelar", exact: true }).click();
+    return {
+        ...context,
+        status: "cancelled",
+        message: "Envío cancelado. No se generó una presentación.",
+    };
+}
+/** The final click is attempted once. A timeout must never trigger another presentation. */
+export async function generatePresentation(page, context, options = {}) {
+    await verifyFormContext(page, { period: context.period, person: context.person.id });
+    const button = submissionDialog(page).getByRole("button", {
+        name: "Generar Presentación",
+        exact: true,
+    });
+    await button.waitFor({ state: "visible", timeout: 15_000 });
+    const previousForms = await readSubmittedForms(page, context, options.timeoutMs).catch(() => null);
+    // Reading history can take time; bind the final action to the current preview again.
+    await verifyFormContext(page, { period: context.period, person: context.person.id });
+    const previewUrl = page.url();
+    try {
+        await button.click({ timeout: options.timeoutMs ?? 30_000 });
+        await page.waitForFunction(({ successPattern, negativePattern, errorSelector, previewUrl }) => {
+            const text = document.querySelector("#contenido")?.innerText ?? "";
+            const visibleError = Array.from(document.querySelectorAll(errorSelector)).some((element) => element.getClientRects().length > 0 && element.textContent?.trim());
+            return (new RegExp(successPattern, "i").test(text) ||
+                new RegExp(negativePattern, "i").test(text) ||
+                visibleError ||
+                /^\s*Error\b/m.test(text) ||
+                location.pathname.includes("expiredSession") ||
+                location.pathname.endsWith("/login.xhtml") ||
+                (location.href !== previewUrl &&
+                    !location.pathname.endsWith("/generacion_presentacion.jsp") &&
+                    document.readyState === "complete"));
+        }, {
+            successPattern: SUCCESS_PATTERN.source,
+            negativePattern: NEGATIVE_PATTERN.source,
+            errorSelector: ERROR_SELECTOR,
+            previewUrl,
+        }, { timeout: options.timeoutMs ?? 30_000 });
+        const error = await readPortalError(page);
+        if (error)
+            return { ...context, status: "rejected", message: `ARCA rechazó la presentación: ${error}` };
+        const text = await page.locator("#contenido").innerText({ timeout: 2_000 });
+        const acknowledgement = text.match(SUCCESS_PATTERN)?.[0];
+        if (acknowledgement) {
+            const reference = text.match(/(?:n[uú]mero|nro\.?|n[°º])\s*(?:de\s+)?presentaci[oó]n\s*:?\s*([\w-]+)/i)?.[1];
+            return {
+                ...context,
+                status: "submitted",
+                message: acknowledgement,
+                confirmationSource: "acknowledgement",
+                ...(reference ? { reference } : {}),
+            };
+        }
+    }
+    catch {
+        // The server may have processed the final click even if navigation or observation failed.
+    }
+    const resultUrl = new URL(page.url());
+    // Strip query parameters: an unknown result should not print private URL values.
+    const finalUrl = `${resultUrl.origin}${resultUrl.pathname}`;
+    let historyMessage = "No se pudo consultar el historial antes del envío para comparar el resultado.";
+    if (previousForms !== null) {
+        const currentForms = await readSubmittedForms(page, context, options.timeoutMs).catch(() => null);
+        if (currentForms === null) {
+            historyMessage = "No se pudo verificar el historial después del envío.";
+        }
+        else {
+            const presentation = findNewSubmittedForm(previousForms, currentForms);
+            if (presentation) {
+                return {
+                    ...context,
+                    status: "submitted",
+                    message: `Presentación n.º ${presentation.number} (${presentation.description}) enviada el ${presentation.submittedAt}, confirmada en «Consulta de Formularios Enviados».`,
+                    reference: String(presentation.number),
+                    submissionType: presentation.description,
+                    submittedAt: presentation.submittedAt,
+                    confirmationSource: "sent-forms",
+                };
+            }
+            historyMessage = currentForms.every((form) => previousForms.some((old) => old.id === form.id))
+                ? "El historial no muestra una presentación nueva respecto del estado previo al envío."
+                : "El historial cambió, pero no se pudo identificar una única presentación nueva de este intento.";
+        }
+    }
+    return {
+        ...context,
+        status: "unconfirmed",
+        resultUrl: finalUrl,
+        message: "Se intentó generar la presentación, pero no se pudo confirmar el resultado.\n" +
+            `${historyMessage}\nPantalla final: ${finalUrl}\n` +
+            "Revisá «Consulta de Formularios Enviados» en ARCA antes de volver a enviar. El CLI no reintentó la presentación.",
+    };
+}
+function submissionDialog(page) {
+    return page
+        .locator(".ui-dialog")
+        .filter({ has: page.locator("#confirmacion_generacion_presentacion") });
+}
+async function readPortalError(page) {
+    return page.evaluate(({ selector, negativePattern }) => {
+        const error = Array.from(document.querySelectorAll(selector)).find((element) => element.getClientRects().length > 0 && element.textContent?.trim());
+        if (error)
+            return error.textContent?.replace(/\s+/g, " ").trim() ?? null;
+        const content = document.querySelector("#contenido")?.innerText ?? "";
+        return /^\s*Error\b/m.test(content) || new RegExp(negativePattern, "i").test(content)
+            ? content.replace(/\s+/g, " ").trim()
+            : null;
+    }, { selector: ERROR_SELECTOR, negativePattern: NEGATIVE_PATTERN.source });
+}

package/dist/src/arca/submitted-forms.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from "playwright";
+import { type FormContext } from "./form.js";
+export type SubmittedForm = {
+    id: string;
+    number: number;
+    description: string;
+    submittedAt: string;
+};
+/** A separate page preserves the draft and its confirmation dialog. */
+export declare function readSubmittedForms(page: Page, context: FormContext, timeoutMs?: number): Promise<SubmittedForm[]>;
+/** Only a single next version with a new record ID can confirm this attempt. */
+export declare function findNewSubmittedForm(before: SubmittedForm[], after: SubmittedForm[]): SubmittedForm | null;

package/dist/src/arca/submitted-forms.js

@@ -0,0 +1,54 @@
+import { verifyFormContext } from "./form.js";
+import { extractInlineJson } from "./http.js";
+import { SIRADIG_BASE_URL } from "./session.js";
+/** A separate page preserves the draft and its confirmation dialog. */
+export async function readSubmittedForms(page, context, timeoutMs = 15_000) {
+    const historyPage = await page.context().newPage();
+    historyPage.setDefaultTimeout(timeoutMs);
+    try {
+        await historyPage.goto(new URL("jsp/verFormulariosEnviados.do", SIRADIG_BASE_URL).href, {
+            waitUntil: "load",
+            timeout: timeoutMs,
+        });
+        await verifyFormContext(historyPage, { period: context.period, person: context.person.id });
+        const table = historyPage.locator("#tabla_formularios");
+        await table.waitFor({ state: "attached", timeout: timeoutMs });
+        const inlineForms = extractInlineJson(await historyPage.content(), "datosFormulariosJSON");
+        const rows = await table.locator("tbody tr").evaluateAll((elements) => elements.map((element) => {
+            const cells = Array.from(element.querySelectorAll("td")).map((cell) => cell.textContent?.replace(/\s+/g, " ").trim() ?? "");
+            return {
+                id: element.getAttribute("data-id-reg") ?? "",
+                number: Number(cells[0]),
+                description: cells[1] ?? "",
+                submittedAt: cells[2] ?? "",
+            };
+        }));
+        if ((Array.isArray(inlineForms) && inlineForms.length !== rows.length) ||
+            (!Array.isArray(inlineForms) && rows.length === 0) ||
+            rows.some((row) => !/^\d+$/.test(row.id) ||
+                !Number.isSafeInteger(row.number) ||
+                row.number < 1 ||
+                !row.description ||
+                !/^\d{2}\/\d{2}\/\d{4}$/.test(row.submittedAt)) ||
+            new Set(rows.map((row) => row.id)).size !== rows.length ||
+            new Set(rows.map((row) => row.number)).size !== rows.length) {
+            throw new Error("El historial de formularios enviados de ARCA tiene un formato desconocido.");
+        }
+        return rows;
+    }
+    finally {
+        await historyPage.close();
+    }
+}
+/** Only a single next version with a new record ID can confirm this attempt. */
+export function findNewSubmittedForm(before, after) {
+    const previousIds = new Set(before.map((form) => form.id));
+    const currentIds = new Set(after.map((form) => form.id));
+    const added = after.filter((form) => !previousIds.has(form.id));
+    const previousNumber = before.reduce((maximum, form) => Math.max(maximum, form.number), 0);
+    if (added.length !== 1 ||
+        before.some((form) => !currentIds.has(form.id)) ||
+        added[0].number !== previousNumber + 1)
+        return null;
+    return added[0];
+}

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

@@ -0,0 +1 @@
+export declare function formatCliError(error: unknown, args?: readonly string[], defaultPassword?: string | undefined): string;

package/dist/src/cli/errors.js

@@ -0,0 +1,11 @@
+import { safeErrorMessage } from "../security/errors.js";
+export function formatCliError(error, args = process.argv.slice(2), defaultPassword = process.env.ARCA_PASSWORD) {
+    const passwords = [defaultPassword];
+    for (const [index, arg] of args.entries()) {
+        if (arg === "--password")
+            passwords.push(args[index + 1]);
+        else if (arg.startsWith("--password="))
+            passwords.push(arg.slice("--password=".length));
+    }
+    return safeErrorMessage(error, passwords);
+}

package/dist/src/cli/help.d.ts

@@ -0,0 +1,6 @@
+import type { HelpCommand } from "./options.js";
+export declare function renderHelp(topic: HelpCommand["topic"], options?: {
+    width?: number;
+    color?: boolean;
+    version?: string;
+}): string;