essalud-cli 0.1.0

package/dist/essalud/cmd-fechas.js

@@ -0,0 +1,47 @@
+import { getProgramacionDisponible } from "./api.js";
+function formatCupo(c, idx) {
+    console.log(`\n  [${idx + 1}] ${c.apeNomProf}`);
+    console.log(`       Fecha      : ${c.fechaCitaProg}`);
+    console.log(`       Turno      : ${c.turnoIni} - ${c.turnoFin}`);
+    console.log(`       Consultorio: ${c.consultorio}`);
+    console.log(`       codProgAsis: ${c.codProgAsis}`);
+    if (c.vCupoDisp && c.vCupoDisp.length > 0) {
+        console.log(`       Slots disponibles (${c.vCupoDisp.length}):`);
+        for (const slot of c.vCupoDisp) {
+            console.log(`         cupo ${String(slot.nroCupo).padStart(3)}  hora ${slot.hora}`);
+        }
+    }
+    else {
+        console.log("       Sin slots disponibles.");
+    }
+}
+export async function cmdFechas(codCentro, codServicioHosp, codActSubAct) {
+    let cupos;
+    try {
+        cupos = await getProgramacionDisponible({
+            codCentro,
+            codServicioHosp,
+            codActSubAct,
+            codTurnoDeseado: "0",
+        });
+    }
+    catch (err) {
+        console.error(String(err));
+        process.exit(1);
+    }
+    if (cupos.length === 0) {
+        console.log(`Sin programación disponible para centro=${codCentro} servicio=${codServicioHosp} actividad=${codActSubAct}.`);
+        return;
+    }
+    console.log(`Cupos disponibles — centro=${codCentro} servicio=${codServicioHosp} actividad=${codActSubAct} (${cupos.length} turnos)`);
+    console.log("─".repeat(60));
+    cupos.forEach(formatCupo);
+    console.log("");
+    console.log("Para reservar, elige un slot y pasa el JSON del cupo:");
+    console.log("  essalud reservar --cupo-json '<json>' --nro-cupo <nro> --hora-slot <hora> --confirm");
+    console.log("Ejemplo (primer slot del primer turno):");
+    if (cupos[0]?.vCupoDisp[0]) {
+        const ejemplo = { ...cupos[0] };
+        console.log(`  essalud reservar --cupo-json '${JSON.stringify(ejemplo)}' --nro-cupo ${cupos[0].vCupoDisp[0].nroCupo} --hora-slot ${cupos[0].vCupoDisp[0].hora}`);
+    }
+}

package/dist/essalud/cmd-login.d.ts

@@ -0,0 +1,7 @@
+export interface LoginOptions {
+    /** JWT to save directly (skip browser) */
+    token?: string;
+    /** Path to a HAR file to extract the token from */
+    fromHar?: string;
+}
+export declare function cmdLogin(opts?: LoginOptions): Promise<void>;

package/dist/essalud/cmd-login.js

@@ -0,0 +1,223 @@
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { chromium } from "playwright";
+import { getPerfil, PACIENTE_PATH, TOKEN_PATH } from "./api.js";
+import { extractPacienteFromHar, extractTokenFromHar, parsePacienteFromLgBody } from "./har.js";
+import { decodeJwtPayload, JWT_RE, looksLikeEsSaludJwt } from "./jwt.js";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const LOGIN_URL = "https://miconsulta.essalud.gob.pe/login";
+const API_HOST = "api.miconsulta.essalud.gob.pe";
+/** Tiempo máximo que esperamos a que el usuario complete el login en el navegador. */
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+// ---------------------------------------------------------------------------
+// Login por navegador (Playwright)
+// ---------------------------------------------------------------------------
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Abre un navegador real (headed), espera a que el usuario se loguee y captura
+ * el Bearer token y los datos del paciente directamente de la red.
+ * Devuelve null si no se pudo capturar (timeout, navegador cerrado, etc.).
+ */
+async function loginWithBrowser() {
+    let browser;
+    try {
+        browser = await chromium.launch({ headless: false });
+    }
+    catch (err) {
+        const msg = String(err);
+        if (/Executable doesn't exist|playwright install/i.test(msg)) {
+            console.error("\nFalta el navegador de Playwright. Instálalo una sola vez con:");
+            console.error("  npx playwright install chromium\n");
+        }
+        else {
+            console.error(`\nNo se pudo abrir el navegador: ${msg}\n`);
+        }
+        return null;
+    }
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    let jwt = null;
+    let paciente = null;
+    // Capturar el Bearer de cualquier request autenticado a la API.
+    context.on("request", (req) => {
+        if (jwt || !req.url().includes(API_HOST))
+            return;
+        const auth = req.headers().authorization ?? "";
+        const m = auth.match(/Bearer\s+(\S+)/i);
+        if (m && looksLikeEsSaludJwt(m[1]))
+            jwt = m[1];
+    });
+    // Capturar paciente (y, como respaldo, el token) del body del login /api/lg.
+    context.on("response", async (res) => {
+        if (!res.url().includes("/api/lg"))
+            return;
+        let body;
+        try {
+            body = await res.text();
+        }
+        catch {
+            return;
+        }
+        paciente = parsePacienteFromLgBody(body) ?? paciente;
+        if (!jwt) {
+            const m = body.match(JWT_RE);
+            if (m && looksLikeEsSaludJwt(m[0]))
+                jwt = m[0];
+        }
+    });
+    await page.goto(LOGIN_URL, { waitUntil: "domcontentloaded" }).catch(() => { });
+    console.log();
+    console.log("─".repeat(60));
+    console.log("Se abrió un navegador en:");
+    console.log(`  ${LOGIN_URL}`);
+    console.log();
+    console.log("Pasos:");
+    console.log("  1. Ingresa tu DNI y clave.");
+    console.log("  2. Completa el captcha de Cloudflare Turnstile.");
+    console.log("  3. Espera a ver tu panel (lista de citas).");
+    console.log();
+    console.log("Voy a capturar tu sesión automáticamente. No cierres esta terminal.");
+    console.log("─".repeat(60));
+    let browserClosed = false;
+    browser.on("disconnected", () => {
+        browserClosed = true;
+    });
+    const start = Date.now();
+    while (!jwt && !browserClosed && Date.now() - start < LOGIN_TIMEOUT_MS) {
+        await sleep(500);
+    }
+    await browser.close().catch(() => { });
+    if (!jwt)
+        return null;
+    return { jwt, paciente };
+}
+// ---------------------------------------------------------------------------
+// Persistencia
+// ---------------------------------------------------------------------------
+async function saveToken(jwt) {
+    await mkdir(dirname(TOKEN_PATH), { recursive: true });
+    await writeFile(TOKEN_PATH, `${jwt}\n`, { encoding: "utf-8", mode: 0o600 });
+    // writeFile mode puede quedar enmascarado por el umask — forzamos los permisos.
+    await chmod(TOKEN_PATH, 0o600);
+}
+async function savePaciente(paciente) {
+    await mkdir(dirname(PACIENTE_PATH), { recursive: true });
+    await writeFile(PACIENTE_PATH, `${JSON.stringify(paciente, null, 2)}\n`, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    await chmod(PACIENTE_PATH, 0o600);
+}
+function pacienteLabel(paciente) {
+    const nombre = [paciente.apePaterno, paciente.apeMaterno, paciente.nombres]
+        .filter(Boolean)
+        .join(" ");
+    return `${nombre} · ${paciente.desCentro}`;
+}
+// ---------------------------------------------------------------------------
+// Validación: confirma el token llamando a /perfil
+// ---------------------------------------------------------------------------
+async function validateAndPrint(jwt) {
+    let perfil;
+    try {
+        perfil = await getPerfil();
+    }
+    catch (err) {
+        throw new Error(`Token guardado pero /perfil falló: ${String(err)}`);
+    }
+    const nombre = [perfil.nombreAsegurado, perfil.apellidoPatAsegurado, perfil.apellidoMatAsegurado]
+        .filter(Boolean)
+        .join(" ");
+    const payload = decodeJwtPayload(jwt);
+    let expInfo = "";
+    if (payload?.exp) {
+        const expDate = new Date(payload.exp * 1000);
+        expInfo = ` | Expira: ${expDate.toLocaleString("es-PE", { timeZone: "America/Lima" })}`;
+    }
+    console.log(`\n✓ Logueado como: ${nombre || "(sin nombre en perfil)"}${expInfo}`);
+}
+// ---------------------------------------------------------------------------
+// Comando principal
+// ---------------------------------------------------------------------------
+export async function cmdLogin(opts = {}) {
+    // Plan B — token pegado a mano.
+    if (opts.token) {
+        const jwt = opts.token.trim().replace(/^Bearer\s+/i, "");
+        if (!jwt.startsWith("ey")) {
+            console.error("Error: el token no parece un JWT válido (debería empezar con 'ey...').");
+            process.exit(1);
+        }
+        await saveToken(jwt);
+        console.log("Token guardado.");
+        await validateAndPrint(jwt);
+        return;
+    }
+    // Plan B — importar desde un HAR exportado de DevTools.
+    if (opts.fromHar) {
+        let content;
+        try {
+            content = await readFile(opts.fromHar, "utf-8");
+        }
+        catch {
+            console.error(`Error: no se pudo leer el HAR: ${opts.fromHar}`);
+            process.exit(1);
+        }
+        const jwt = extractTokenFromHar(opts.fromHar, content);
+        if (!jwt) {
+            console.error(`No se encontró ningún header Authorization: Bearer en requests a ${API_HOST} en el HAR.`);
+            console.error("Verifica que el HAR incluya requests autenticados al panel (no solo el login).");
+            process.exit(1);
+        }
+        await saveToken(jwt);
+        console.log("Token extraído del HAR y guardado.");
+        const paciente = extractPacienteFromHar(content);
+        if (paciente) {
+            await savePaciente(paciente);
+            console.log(`Paciente guardado: ${pacienteLabel(paciente)}`);
+        }
+        await validateAndPrint(jwt);
+        return;
+    }
+    // Plan A — navegador headed + captura automática (Playwright).
+    const result = await loginWithBrowser();
+    if (result) {
+        await saveToken(result.jwt);
+        if (result.paciente) {
+            await savePaciente(result.paciente);
+            console.log(`Paciente guardado: ${pacienteLabel(result.paciente)}`);
+        }
+        try {
+            await validateAndPrint(result.jwt);
+        }
+        catch (err) {
+            console.error(String(err));
+            process.exit(1);
+        }
+        return;
+    }
+    // Falló la captura automática → ofrecer los caminos manuales.
+    console.error();
+    console.error("No se pudo capturar el token automáticamente.");
+    console.error("Posibles causas: no completaste el login, Turnstile bloqueó, o cerraste el navegador.");
+    console.error();
+    console.error("Opciones para continuar:");
+    console.error();
+    console.error("  Opción A — pegar el token manualmente:");
+    console.error("    1. Abre https://miconsulta.essalud.gob.pe en Chrome");
+    console.error("    2. Inicia sesión y abre DevTools (F12) → Network");
+    console.error("    3. Filtra por 'api.miconsulta' → haz click en cualquier request");
+    console.error("    4. En Headers, copia el valor de: Authorization: Bearer <token>");
+    console.error("    5. Corre:");
+    console.error("         essalud login --token <token>");
+    console.error();
+    console.error("  Opción B — importar desde HAR:");
+    console.error("    1. En DevTools → Network → Export HAR (ícono de descarga)");
+    console.error("    2. Corre:");
+    console.error("         essalud login --from-har ~/Downloads/captura.har");
+    console.error();
+    process.exit(1);
+}

package/dist/essalud/cmd-perfil.d.ts

@@ -0,0 +1 @@
+export declare function cmdPerfil(): Promise<void>;

package/dist/essalud/cmd-perfil.js

@@ -0,0 +1,38 @@
+import { getPaciente, getPerfil } from "./api.js";
+function printField(label, value) {
+    if (value === null || value === undefined || value === "")
+        return;
+    if (typeof value === "object") {
+        // Expandir objetos anidados (p.ej. contacto)
+        for (const [k, v] of Object.entries(value)) {
+            printField(`${label}.${k}`, v);
+        }
+    }
+    else {
+        console.log(`${label.padEnd(20)} : ${String(value)}`);
+    }
+}
+export async function cmdPerfil() {
+    let perfil;
+    try {
+        perfil = await getPerfil();
+    }
+    catch (err) {
+        console.error(String(err));
+        process.exit(1);
+    }
+    const paciente = await getPaciente();
+    console.log("Perfil EsSalud");
+    console.log("─".repeat(40));
+    // Datos enriquecidos desde paciente.json (que /perfil no trae)
+    if (paciente) {
+        const nombre = [paciente.apePaterno, paciente.apeMaterno, paciente.nombres]
+            .filter(Boolean)
+            .join(" ");
+        console.log(`${"Nombre".padEnd(20)} : ${nombre}`);
+        console.log(`${"Centro".padEnd(20)} : ${paciente.desCentro}`);
+    }
+    for (const [k, v] of Object.entries(perfil)) {
+        printField(k, v);
+    }
+}

package/dist/essalud/cmd-reservar.d.ts

@@ -0,0 +1,14 @@
+export interface ReservarOptions {
+    cupoJson?: string;
+    nroCupo?: string;
+    horaSlot?: string;
+    codProgAsis?: string;
+    consultorio?: string;
+    fecha?: string;
+    turnoIni?: string;
+    turnoFin?: string;
+    celular?: string;
+    email?: string;
+    confirm: boolean;
+}
+export declare function cmdReservar(opts: ReservarOptions): Promise<void>;

package/dist/essalud/cmd-reservar.js

@@ -0,0 +1,147 @@
+import { createInterface } from "node:readline";
+import { generarCita, getPerfil } from "./api.js";
+async function confirmarInteractivo(mensaje) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(`${mensaje} [s/N] `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "s");
+        });
+    });
+}
+export async function cmdReservar(opts) {
+    // Resolver el cupo desde --cupo-json o desde flags individuales
+    let cupoData = {};
+    if (opts.cupoJson) {
+        try {
+            cupoData = JSON.parse(opts.cupoJson);
+        }
+        catch {
+            console.error("Error: --cupo-json no es JSON válido.");
+            process.exit(1);
+        }
+    }
+    else {
+        if (opts.codProgAsis)
+            cupoData.codProgAsis = opts.codProgAsis;
+        if (opts.consultorio)
+            cupoData.consultorio = opts.consultorio;
+        if (opts.fecha)
+            cupoData.fechaCitaProg = opts.fecha;
+        if (opts.turnoIni)
+            cupoData.turnoIni = opts.turnoIni;
+        if (opts.turnoFin)
+            cupoData.turnoFin = opts.turnoFin;
+    }
+    // --nro-cupo es obligatorio (elige el slot de vCupoDisp)
+    if (!opts.nroCupo) {
+        console.error("Error: falta --nro-cupo (elige un slot de la salida de 'fechas').");
+        process.exit(1);
+    }
+    const nroCupo = Number(opts.nroCupo);
+    if (Number.isNaN(nroCupo)) {
+        console.error(`Error: --nro-cupo debe ser un número; se recibió "${opts.nroCupo}".`);
+        process.exit(1);
+    }
+    // Validar campos obligatorios del cupo
+    const requiredFields = [
+        "codProgAsis",
+        "consultorio",
+        "fechaCitaProg",
+        "turnoIni",
+        "turnoFin",
+    ];
+    for (const field of requiredFields) {
+        if (!cupoData[field]) {
+            console.error(`Error: falta el campo "${field}". Usa --cupo-json '<json>' o los flags individuales.`);
+            process.exit(1);
+        }
+    }
+    // Resolver numCelular y email: flags > perfil
+    let numCelular = opts.celular ?? "";
+    let email = opts.email ?? "";
+    if (!numCelular || !email) {
+        let perfil;
+        try {
+            perfil = await getPerfil();
+        }
+        catch (err) {
+            console.error(`Error al obtener perfil: ${String(err)}`);
+            process.exit(1);
+        }
+        if (!numCelular)
+            numCelular = perfil.contacto?.nroCelular ?? "";
+        if (!email)
+            email = perfil.contacto?.email ?? "";
+    }
+    if (!numCelular || !email) {
+        console.error("Error: no se encontró celular/email en el perfil. Pásalos con --celular y --email.");
+        process.exit(1);
+    }
+    // Encontrar la hora del slot si se pasó --hora-slot (para mostrar)
+    let horaDisplay = opts.horaSlot ?? "(no especificada)";
+    if (!opts.horaSlot && cupoData.vCupoDisp) {
+        const slot = cupoData.vCupoDisp.find((s) => s.nroCupo === nroCupo);
+        if (slot)
+            horaDisplay = slot.hora;
+    }
+    // Construir el payload final
+    const payload = {
+        codProgAsis: cupoData.codProgAsis,
+        consultorio: cupoData.consultorio,
+        fechaCitaPro: cupoData.fechaCitaProg,
+        nroCupo,
+        turnoIni: cupoData.turnoIni,
+        turnoFin: cupoData.turnoFin,
+        numCelular,
+        email,
+    };
+    // Mostrar resumen
+    console.log("Resumen de la cita a reservar:");
+    console.log("─".repeat(50));
+    if (cupoData.apeNomProf)
+        console.log(`  Profesional    : ${cupoData.apeNomProf}`);
+    console.log(`  Fecha          : ${payload.fechaCitaPro}`);
+    console.log(`  Hora del slot  : ${horaDisplay}`);
+    console.log(`  Cupo nro       : ${payload.nroCupo}`);
+    console.log(`  Turno          : ${payload.turnoIni} - ${payload.turnoFin}`);
+    console.log(`  Consultorio    : ${payload.consultorio}`);
+    console.log(`  codProgAsis    : ${payload.codProgAsis}`);
+    console.log(`  Celular        : ${payload.numCelular}`);
+    console.log(`  Email          : ${payload.email}`);
+    console.log("");
+    // DRY-RUN por defecto
+    if (!opts.confirm) {
+        console.log("[dry-run] No se realizó ninguna reserva real.");
+        console.log("Para reservar de verdad: agrega --confirm al comando.");
+        return;
+    }
+    // Confirmación interactiva obligatoria
+    const ok = await confirmarInteractivo("ADVERTENCIA: Esto agenda una cita REAL en EsSalud. ¿Confirmas? (ocupa un cupo)");
+    if (!ok) {
+        console.log("Cancelado. No se realizó ninguna reserva.");
+        return;
+    }
+    // POST generarCita
+    let result;
+    try {
+        result = await generarCita(payload);
+    }
+    catch (err) {
+        console.error(`Error al generar la cita: ${String(err)}`);
+        process.exit(1);
+    }
+    const cita = result[0];
+    console.log("\nCita reservada exitosamente.");
+    console.log("─".repeat(50));
+    if (cita?.numCitaCreada)
+        console.log(`  Nro cita   : ${cita.numCitaCreada}`);
+    if (cita?.fechaCita)
+        console.log(`  Fecha      : ${cita.fechaCita}`);
+    if (cita?.horaCita)
+        console.log(`  Hora       : ${cita.horaCita}`);
+    if (cita?.apeNomProf)
+        console.log(`  Profesional: ${cita.apeNomProf}`);
+    if (cita?.desServHosp)
+        console.log(`  Servicio   : ${cita.desServHosp}`);
+}

package/dist/essalud/cmd-token.d.ts

@@ -0,0 +1 @@
+export declare function cmdToken(): Promise<void>;

package/dist/essalud/cmd-token.js

@@ -0,0 +1,62 @@
+import { readToken, TOKEN_PATH } from "./api.js";
+import { decodeJwtPayload } from "./jwt.js";
+export async function cmdToken() {
+    let token;
+    try {
+        token = await readToken();
+    }
+    catch (err) {
+        console.error(String(err));
+        process.exit(1);
+    }
+    const payload = decodeJwtPayload(token);
+    if (!payload) {
+        console.log("Token guardado pero no es un JWT válido (no se puede decodificar).");
+        return;
+    }
+    const exp = typeof payload.exp === "number" ? payload.exp : null;
+    const iat = typeof payload.iat === "number" ? payload.iat : null;
+    // El JWT de EsSalud usa user_name (no sub) y scope es un array
+    const userName = typeof payload.user_name === "string"
+        ? payload.user_name
+        : typeof payload.sub === "string"
+            ? payload.sub
+            : null;
+    const scope = Array.isArray(payload.scope)
+        ? payload.scope.join(", ")
+        : typeof payload.scope === "string"
+            ? payload.scope
+            : null;
+    const clientId = typeof payload.client_id === "string" ? payload.client_id : null;
+    const now = Math.floor(Date.now() / 1000);
+    const expired = exp !== null ? now > exp : null;
+    console.log("Token EsSalud");
+    console.log("─".repeat(40));
+    console.log(`Archivo   : ${TOKEN_PATH}`);
+    if (userName)
+        console.log(`Usuario   : ${userName}`);
+    if (clientId)
+        console.log(`Cliente   : ${clientId}`);
+    if (scope)
+        console.log(`Scope     : ${scope}`);
+    if (iat)
+        console.log(`Emitido   : ${new Date(iat * 1000).toLocaleString("es-PE")}`);
+    if (exp) {
+        const expiresAt = new Date(exp * 1000).toLocaleString("es-PE");
+        const secsLeft = exp - now;
+        if (expired) {
+            console.log(`Vence     : ${expiresAt}  (VENCIDO hace ${Math.abs(secsLeft)}s)`);
+            console.log("\nEl token está vencido. Necesitas obtener uno nuevo.");
+        }
+        else {
+            const minsLeft = Math.floor(secsLeft / 60);
+            const hoursLeft = Math.floor(minsLeft / 60);
+            const display = hoursLeft > 0 ? `${hoursLeft}h ${minsLeft % 60}min` : `${minsLeft} min`;
+            console.log(`Vence     : ${expiresAt}  (en ${display})`);
+            console.log("\nToken vigente.");
+        }
+    }
+    else {
+        console.log("Vence     : (sin campo exp)");
+    }
+}

package/dist/essalud/har.d.ts

@@ -0,0 +1,7 @@
+import type { PacienteData } from "./api.js";
+/** Extrae los datos del paciente del body JSON de la respuesta /api/lg. */
+export declare function parsePacienteFromLgBody(responseText: string): PacienteData | null;
+/** Extrae el JWT Bearer más reciente de un HAR. */
+export declare function extractTokenFromHar(harPath: string, harContent: string): string | null;
+/** Busca la entry /api/lg en el HAR y extrae datos del paciente. */
+export declare function extractPacienteFromHar(harContent: string): PacienteData | null;

package/dist/essalud/har.js

@@ -0,0 +1,76 @@
+// Helpers puros para extraer el token y los datos del paciente de un HAR
+// exportado de DevTools, o del body de la respuesta /api/lg del login.
+import { JWT_RE, looksLikeEsSaludJwt } from "./jwt.js";
+/** Extrae los datos del paciente del body JSON de la respuesta /api/lg. */
+export function parsePacienteFromLgBody(responseText) {
+    if (!responseText)
+        return null;
+    try {
+        const json = JSON.parse(responseText);
+        const raw = json?.data?.paciente;
+        if (!raw)
+            return null;
+        return {
+            codCentro: raw.codCentro ?? "",
+            desCentro: raw.desCentro ?? "",
+            apePaterno: raw.apePaterno ?? "",
+            apeMaterno: raw.apeMaterno ?? "",
+            nombres: raw.nombres ?? null,
+            email: raw.email ?? null,
+            celular: raw.nroCelular ?? raw.celular ?? null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Extrae el JWT Bearer más reciente de un HAR. */
+export function extractTokenFromHar(harPath, harContent) {
+    let har;
+    try {
+        har = JSON.parse(harContent);
+    }
+    catch {
+        throw new Error(`HAR inválido (no es JSON válido): ${harPath}`);
+    }
+    const entries = har.log?.entries ?? [];
+    const candidates = [];
+    for (const entry of entries) {
+        const req = entry.request;
+        const resp = entry.response;
+        // 1) Header Authorization: Bearer <jwt> (cuando el HAR lo conserva).
+        const authHeader = req?.headers?.find((h) => h.name.toLowerCase() === "authorization");
+        const authMatch = authHeader?.value.match(/Bearer\s+(\S+)/i);
+        if (authMatch && looksLikeEsSaludJwt(authMatch[1]))
+            candidates.push(authMatch[1]);
+        // 2) JWT embebido en el body (el login /api/lg devuelve el token ahí; Chrome
+        //    NO exporta el header Authorization al HAR, pero sí el body).
+        for (const blob of [resp?.content?.text ?? "", req?.postData?.text ?? ""]) {
+            const m = blob.match(JWT_RE);
+            if (m && looksLikeEsSaludJwt(m[0]))
+                candidates.push(m[0]);
+        }
+    }
+    if (candidates.length === 0)
+        return null;
+    // El más reciente (los HAR son cronológicos).
+    return candidates[candidates.length - 1];
+}
+/** Busca la entry /api/lg en el HAR y extrae datos del paciente. */
+export function extractPacienteFromHar(harContent) {
+    let har;
+    try {
+        har = JSON.parse(harContent);
+    }
+    catch {
+        return null;
+    }
+    for (const entry of har.log?.entries ?? []) {
+        if (!(entry.request?.url ?? "").includes("/api/lg"))
+            continue;
+        const paciente = parsePacienteFromLgBody(entry.response?.content?.text ?? "");
+        if (paciente)
+            return paciente;
+    }
+    return null;
+}

package/dist/essalud/index.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function makeEssaludCommand(): Command;