essalud-cli 0.1.0

package/dist/essalud/index.js

@@ -0,0 +1,87 @@
+import { Command } from "commander";
+import { cmdCancelar } from "./cmd-cancelar.js";
+import { cmdCitas } from "./cmd-citas.js";
+import { cmdEspecialidades } from "./cmd-especialidades.js";
+import { cmdFechas } from "./cmd-fechas.js";
+import { cmdLogin } from "./cmd-login.js";
+import { cmdPerfil } from "./cmd-perfil.js";
+import { cmdReservar } from "./cmd-reservar.js";
+import { cmdToken } from "./cmd-token.js";
+import { runInteractiveMode } from "./interactive.js";
+export function makeEssaludCommand() {
+    const essalud = new Command("essalud")
+        .description("Trámites de EsSalud (citas, perfil, etc.)")
+        // Si no se pasa ningún subcomando, lanzar el modo interactivo
+        .action(() => {
+        void runInteractiveMode();
+    });
+    essalud.command("perfil").description("Muestra los datos del asegurado").action(cmdPerfil);
+    essalud.command("citas").description("Lista las citas emitidas").action(cmdCitas);
+    essalud
+        .command("token")
+        .description("Verifica si hay token guardado y si está vigente")
+        .action(cmdToken);
+    essalud
+        .command("login")
+        .description("Login asistido: abre browser headed, captura el Bearer token de EsSalud y lo guarda.")
+        .option("--token <jwt>", "Pegar el JWT directamente (sin abrir browser)")
+        .option("--from-har <path>", "Importar token desde un HAR exportado de DevTools")
+        .action((opts) => {
+        const loginOpts = {
+            token: opts.token,
+            fromHar: opts.fromHar,
+        };
+        return cmdLogin(loginOpts);
+    });
+    essalud
+        .command("especialidades <codCentro>")
+        .description("Lista especialidades y actividades disponibles para un centro (POST /parametroSolicitud).")
+        .action((codCentro) => cmdEspecialidades(codCentro));
+    essalud
+        .command("fechas <codCentro> <codServicioHosp> <codActSubAct>")
+        .description("Muestra cupos y slots disponibles para una especialidad/actividad (POST /programacionDisponible).")
+        .action((codCentro, codServicioHosp, codActSubAct) => cmdFechas(codCentro, codServicioHosp, codActSubAct));
+    essalud
+        .command("reservar")
+        .description("Reserva una cita. Dry-run por defecto. Requiere --confirm para el POST real a /generarCita.")
+        .option("--cupo-json <json>", "JSON del cupo completo (de la salida de 'fechas')")
+        .option("--nro-cupo <nro>", "Número de cupo a reservar (de vCupoDisp[].nroCupo)")
+        .option("--hora-slot <hora>", "Hora del slot elegido (solo para mostrar en el resumen)")
+        .option("--cod-prog-asis <cod>", "codProgAsis del cupo (alternativa a --cupo-json)")
+        .option("--consultorio <cod>", "Consultorio (alternativa a --cupo-json)")
+        .option("--fecha <fecha>", "fechaCitaProg del cupo (alternativa a --cupo-json)")
+        .option("--turno-ini <hora>", "turnoIni (alternativa a --cupo-json)")
+        .option("--turno-fin <hora>", "turnoFin (alternativa a --cupo-json)")
+        .option("--celular <nro>", "Número de celular (por defecto del perfil)")
+        .option("--email <email>", "Email (por defecto del perfil)")
+        .option("--confirm", "Ejecutar la reserva real (requiere confirmación interactiva)")
+        .action((opts) => {
+        const reservarOpts = {
+            cupoJson: opts.cupoJson,
+            nroCupo: opts.nroCupo,
+            horaSlot: opts.horaSlot,
+            codProgAsis: opts.codProgAsis,
+            consultorio: opts.consultorio,
+            fecha: opts.fecha,
+            turnoIni: opts.turnoIni,
+            turnoFin: opts.turnoFin,
+            celular: opts.celular,
+            email: opts.email,
+            confirm: opts.confirm ?? false,
+        };
+        return cmdReservar(reservarOpts);
+    });
+    essalud
+        .command("cancelar <citActMedNum>")
+        .description("Cancela una cita (POST /eliminarCita). Dry-run por defecto; requiere --confirm.")
+        .option("--cod-centro <cod>", "Código del centro de la cita (citCenAsiCod), si no aparece en 'citas'")
+        .option("--confirm", "Ejecutar la cancelación real (requiere confirmación interactiva)")
+        .action((citActMedNum, opts) => {
+        const cancelarOpts = {
+            confirm: opts.confirm ?? false,
+            codCentro: opts.codCentro,
+        };
+        return cmdCancelar(citActMedNum, cancelarOpts);
+    });
+    return essalud;
+}

package/dist/essalud/interactive.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Modo interactivo de EsSalud — menú estilo command palette usando @clack/prompts.
+ * Se lanza cuando se corre `essalud` sin subcomando.
+ */
+export declare function runInteractiveMode(): Promise<void>;

package/dist/essalud/interactive.js

@@ -0,0 +1,495 @@
+/**
+ * Modo interactivo de EsSalud — menú estilo command palette usando @clack/prompts.
+ * Se lanza cuando se corre `essalud` sin subcomando.
+ */
+import { readFile } from "node:fs/promises";
+import * as p from "@clack/prompts";
+import boxen from "boxen";
+import figlet from "figlet";
+import pc from "picocolors";
+import { generarCita, getCitasEmitidas, getPaciente, getParametroSolicitud, getPerfil, getProgramacionDisponible, request, TOKEN_PATH, } from "./api.js";
+import { cmdLogin } from "./cmd-login.js";
+import { decodeJwtPayload } from "./jwt.js";
+async function getTokenStatus() {
+    try {
+        const raw = await readFile(TOKEN_PATH, "utf-8");
+        const token = raw.trim();
+        if (!token.startsWith("ey")) {
+            return { valid: false, expired: false, expiresAt: null, token: null };
+        }
+        const payload = decodeJwtPayload(token);
+        if (payload && typeof payload.exp === "number") {
+            const expiresAt = new Date(payload.exp * 1000);
+            const expired = Date.now() > payload.exp * 1000;
+            return { valid: true, expired, expiresAt, token };
+        }
+        // JWT sin exp legible: lo tratamos como válido sin info de expiración.
+        return { valid: true, expired: false, expiresAt: null, token };
+    }
+    catch {
+        return { valid: false, expired: false, expiresAt: null, token: null };
+    }
+}
+// ---------------------------------------------------------------------------
+// Banner de bienvenida
+// ---------------------------------------------------------------------------
+function printWordmark() {
+    try {
+        const art = figlet.textSync("essalud", { font: "ANSI Shadow" });
+        console.log(pc.cyan(art));
+    }
+    catch {
+        // Fallback si figlet falla por alguna razón
+        console.log(pc.cyan("\n  essalud\n"));
+    }
+}
+async function printBanner(ts) {
+    printWordmark();
+    const paciente = await getPaciente();
+    // Saludo
+    const nombreMostrado = paciente?.nombres?.trim() || paciente?.apePaterno?.trim() || null;
+    const saludoLine = nombreMostrado ? `Hola, ${nombreMostrado}` : "Hola";
+    // Estado del token
+    let estadoLine;
+    if (!ts.valid || !ts.token) {
+        estadoLine = pc.yellow("no logueada — corre login");
+    }
+    else if (ts.expired) {
+        estadoLine = pc.red("VENCIDO — corre login");
+    }
+    else {
+        // Extraer DNI del JWT (sub) o mostrar genérico
+        const payload = decodeJwtPayload(ts.token ?? "");
+        const dni = (typeof payload?.sub === "string" && payload.sub) ||
+            (typeof payload?.username === "string" && payload.username) ||
+            (typeof payload?.preferred_username === "string" && payload.preferred_username) ||
+            "";
+        const dniStr = dni ? ` · DNI ${dni}` : "";
+        const venceStr = ts.expiresAt
+            ? ` · vence ${ts.expiresAt.toLocaleString("es-PE", { timeZone: "America/Lima", dateStyle: "short", timeStyle: "short" })}`
+            : "";
+        estadoLine = pc.green(`logueada${dniStr}${venceStr}`);
+    }
+    // Centro
+    const centroLine = paciente?.desCentro
+        ? `Centro: ${paciente.desCentro}`
+        : "Centro: (desconocido — corre login)";
+    const content = [
+        pc.bold("essalud · citas EsSalud"),
+        "",
+        saludoLine,
+        estadoLine,
+        centroLine,
+        "",
+        pc.dim("Elige una opción ↓"),
+    ].join("\n");
+    console.log(boxen(content, {
+        padding: { top: 0, bottom: 0, left: 2, right: 2 },
+        margin: { top: 1, bottom: 0, left: 0, right: 0 },
+        borderStyle: "round",
+        borderColor: "#E8845A",
+        textAlignment: "center",
+    }));
+}
+// ---------------------------------------------------------------------------
+// Guard: exige login activo
+// ---------------------------------------------------------------------------
+async function requireLogin(ts) {
+    if (ts.valid && !ts.expired)
+        return true;
+    p.log.warn(ts.expired
+        ? "Tu token venció. Necesitas hacer login nuevamente."
+        : "No hay sesión activa. Primero haz login.");
+    const ir = await p.confirm({ message: "¿Quieres hacer login ahora?" });
+    if (p.isCancel(ir) || !ir)
+        return false;
+    await runLogin();
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Subrutinas de cada opción del menú
+// ---------------------------------------------------------------------------
+async function runLogin() {
+    p.log.info("Iniciando login...");
+    try {
+        await cmdLogin({});
+    }
+    catch (err) {
+        p.log.error(String(err));
+    }
+}
+async function runPerfil(ts) {
+    if (!(await requireLogin(ts)))
+        return;
+    const s = p.spinner();
+    s.start("Cargando perfil...");
+    try {
+        const [perfil, paciente] = await Promise.all([getPerfil(), getPaciente()]);
+        s.stop("Perfil cargado.");
+        printPerfil(perfil, paciente);
+    }
+    catch (err) {
+        s.stop("Error al cargar el perfil.");
+        p.log.error(String(err));
+    }
+}
+function printPerfil(perfil, paciente) {
+    // /perfil trae nombre separado; enricher con paciente.json si hay
+    const nombreApi = [
+        perfil.apellidoPatAsegurado,
+        perfil.apellidoMatAsegurado,
+        perfil.nombreAsegurado,
+    ]
+        .filter(Boolean)
+        .join(" ");
+    const nombrePaciente = paciente
+        ? [paciente.apePaterno, paciente.apeMaterno, paciente.nombres].filter(Boolean).join(" ")
+        : "";
+    const nombre = nombrePaciente || nombreApi || "(sin datos)";
+    const centro = paciente?.desCentro ?? "—";
+    const contacto = perfil.contacto;
+    p.note([
+        `Nombre   : ${nombre}`,
+        `Centro   : ${centro}`,
+        `DNI      : ${perfil.numeroDocIdent ?? "—"}`,
+        `Celular  : ${contacto?.nroCelular ?? paciente?.celular ?? "—"}`,
+        `Email    : ${contacto?.email ?? paciente?.email ?? "—"}`,
+    ].join("\n"), "Mi perfil");
+}
+async function runCitas(ts) {
+    if (!(await requireLogin(ts)))
+        return;
+    const s = p.spinner();
+    s.start("Cargando citas...");
+    try {
+        const citas = await getCitasEmitidas();
+        s.stop(`${citas.length} cita(s) encontrada(s).`);
+        if (citas.length === 0) {
+            p.log.info("No tienes citas programadas.");
+            return;
+        }
+        printCitas(citas);
+    }
+    catch (err) {
+        s.stop("Error al cargar las citas.");
+        p.log.error(String(err));
+    }
+}
+function printCitas(citas) {
+    const lines = citas.map((c, i) => {
+        const fecha = c.citFecha ?? "—";
+        const hora = c.citHora ?? "—";
+        const centro = c.citCenAsiDes ?? "—";
+        const estado = c.citEstCita ?? "—";
+        const id = c.citActMedNum ?? c.citAutoGenCod ?? "—";
+        return `${i + 1}. [${id}] ${fecha} ${hora} · ${centro} · ${estado}`;
+    });
+    p.note(lines.join("\n"), "Mis citas");
+}
+// ---------------------------------------------------------------------------
+// Reservar cita — flujo guiado
+// ---------------------------------------------------------------------------
+async function runReservar(ts) {
+    if (!(await requireLogin(ts)))
+        return;
+    // --- Paso 1: centro — tomarlo de paciente.json sin preguntar ---
+    const paciente = await getPaciente();
+    let codCentro;
+    if (paciente?.codCentro) {
+        codCentro = paciente.codCentro;
+        p.log.info(`Centro: ${paciente.desCentro} (${codCentro})`);
+    }
+    else {
+        // Fallback: preguntar solo si no hay paciente.json
+        const codCentroRaw = await p.text({
+            message: "Código de tu centro de adscripción (Enter para usar 021, tu centro default)",
+            placeholder: "021",
+            defaultValue: "021",
+        });
+        if (p.isCancel(codCentroRaw))
+            return;
+        codCentro = codCentroRaw.trim() || "021";
+    }
+    // --- Paso 2: especialidades ---
+    const s1 = p.spinner();
+    s1.start("Consultando especialidades...");
+    let servicios = [];
+    try {
+        const data = await getParametroSolicitud(codCentro);
+        servicios = data.dataParmServicioHosp ?? [];
+        s1.stop(`${servicios.length} especialidad(es) disponible(s).`);
+    }
+    catch (err) {
+        s1.stop("Error al consultar especialidades.");
+        p.log.error(String(err));
+        return;
+    }
+    if (servicios.length === 0) {
+        p.log.warn("No se encontraron especialidades para ese centro.");
+        return;
+    }
+    const servicioOptions = servicios.map((sv) => ({
+        value: sv.codServicioHosp,
+        label: sv.desServicioHosp,
+        hint: sv.codServicioHosp,
+    }));
+    const codServicioHosp = await p.select({
+        message: "Elige la especialidad",
+        options: servicioOptions,
+    });
+    if (p.isCancel(codServicioHosp))
+        return;
+    const servicioElegido = servicios.find((sv) => sv.codServicioHosp === codServicioHosp);
+    if (!servicioElegido)
+        return;
+    // --- Paso 3: actividad (si hay más de una) ---
+    let codActSubAct;
+    const actividades = servicioElegido.vdataActSubAct ?? [];
+    if (actividades.length === 0) {
+        p.log.warn("Esta especialidad no tiene actividades configuradas.");
+        return;
+    }
+    else if (actividades.length === 1 && actividades[0]) {
+        codActSubAct = actividades[0].codActSubAct;
+        p.log.info(`Actividad: ${actividades[0].desSubActHosp}`);
+    }
+    else {
+        const actOpts = actividades.map((a) => ({
+            value: a.codActSubAct,
+            label: a.desSubActHosp,
+            hint: a.desActHosp ?? a.codActSubAct,
+        }));
+        const chosenAct = await p.select({
+            message: "Elige la actividad",
+            options: actOpts,
+        });
+        if (p.isCancel(chosenAct))
+            return;
+        codActSubAct = chosenAct;
+    }
+    // --- Paso 4: cupos disponibles ---
+    const s2 = p.spinner();
+    s2.start("Buscando cupos disponibles...");
+    let cupos = [];
+    try {
+        cupos = await getProgramacionDisponible({
+            codCentro,
+            codServicioHosp: codServicioHosp,
+            codActSubAct,
+            codTurnoDeseado: "0",
+        });
+        s2.stop(`${cupos.length} cupo(s) disponible(s).`);
+    }
+    catch (err) {
+        s2.stop("Error al consultar cupos.");
+        p.log.error(String(err));
+        return;
+    }
+    if (cupos.length === 0) {
+        p.log.warn("Sin programación disponible para esta especialidad/actividad. Intenta otra.");
+        return;
+    }
+    const opciones = [];
+    for (const cupo of cupos) {
+        for (const slot of cupo.vCupoDisp ?? []) {
+            opciones.push({ cupo, slot });
+        }
+    }
+    if (opciones.length === 0) {
+        p.log.warn("Los cupos no tienen slots disponibles.");
+        return;
+    }
+    const slotOpts = opciones.map((o, i) => ({
+        value: String(i),
+        label: `${o.cupo.apeNomProf} — ${o.cupo.fechaCitaProg} ${o.slot.hora}`,
+        hint: `Cupo #${o.slot.nroCupo} · Consul. ${o.cupo.consultorio}`,
+    }));
+    const chosenSlotIdx = await p.select({
+        message: "Elige un cupo",
+        options: slotOpts,
+    });
+    if (p.isCancel(chosenSlotIdx))
+        return;
+    const elegido = opciones[Number(chosenSlotIdx)];
+    if (!elegido)
+        return;
+    // --- Paso 5: resumen + confirmación ---
+    p.note([
+        `Profesional : ${elegido.cupo.apeNomProf}`,
+        `Fecha       : ${elegido.cupo.fechaCitaProg}`,
+        `Hora        : ${elegido.slot.hora}`,
+        `Cupo #      : ${elegido.slot.nroCupo}`,
+        `Consultorio : ${elegido.cupo.consultorio}`,
+        `Especialidad: ${servicioElegido.desServicioHosp}`,
+    ].join("\n"), "Resumen de la cita");
+    const confirma = await p.confirm({
+        message: "¿Reservar esta cita REAL? (ocupa un cupo real en EsSalud)",
+        initialValue: false,
+    });
+    if (p.isCancel(confirma) || !confirma) {
+        p.log.info("Reserva cancelada. No se realizó ninguna acción.");
+        return;
+    }
+    // --- Paso 6: obtener datos de contacto del perfil ---
+    const s3 = p.spinner();
+    s3.start("Obteniendo datos de contacto...");
+    let numCelular = "";
+    let email = "";
+    try {
+        const perfil = await getPerfil();
+        numCelular = perfil.contacto?.nroCelular ?? "";
+        email = perfil.contacto?.email ?? "";
+        s3.stop("Datos obtenidos.");
+    }
+    catch {
+        s3.stop("No se pudo obtener el perfil; continuando sin datos de contacto.");
+    }
+    // --- Paso 7: generarCita ---
+    const s4 = p.spinner();
+    s4.start("Reservando cita...");
+    try {
+        const result = await generarCita({
+            codProgAsis: elegido.cupo.codProgAsis,
+            consultorio: elegido.cupo.consultorio,
+            fechaCitaPro: elegido.cupo.fechaCitaProg,
+            nroCupo: elegido.slot.nroCupo,
+            turnoIni: elegido.cupo.turnoIni,
+            turnoFin: elegido.cupo.turnoFin,
+            numCelular,
+            email,
+        });
+        s4.stop("Cita reservada.");
+        const cita = result[0];
+        if (cita) {
+            p.note([
+                `N° de cita  : ${cita.numCitaCreada ?? "—"}`,
+                `Fecha       : ${cita.fechaCita ?? elegido.cupo.fechaCitaProg}`,
+                `Hora        : ${cita.horaCita ?? elegido.slot.hora}`,
+                `Profesional : ${cita.apeNomProf ?? elegido.cupo.apeNomProf}`,
+                `Especialidad: ${cita.desServHosp ?? servicioElegido.desServicioHosp}`,
+            ].join("\n"), "Cita confirmada");
+        }
+    }
+    catch (err) {
+        s4.stop("Error al reservar la cita.");
+        p.log.error(String(err));
+    }
+}
+// ---------------------------------------------------------------------------
+// Cancelar cita — flujo guiado
+// ---------------------------------------------------------------------------
+async function runCancelar(ts) {
+    if (!(await requireLogin(ts)))
+        return;
+    const s = p.spinner();
+    s.start("Cargando citas...");
+    let citas = [];
+    try {
+        citas = await getCitasEmitidas();
+    }
+    catch (err) {
+        s.stop("Error al cargar las citas.");
+        p.log.error(String(err));
+        return;
+    }
+    // Solo ofrecemos las que la API marca como cancelables (deja fuera las anuladas).
+    const cancelables = citas.filter((c) => c.puedeCancelar === true);
+    s.stop(`${citas.length} cita(s); ${cancelables.length} cancelable(s).`);
+    if (cancelables.length === 0) {
+        p.log.info("No hay citas que puedas cancelar (las anuladas no cuentan).");
+        return;
+    }
+    const opts = cancelables.map((c) => {
+        const id = c.citActMedNum ?? c.citAutoGenCod ?? "?";
+        const fecha = c.citFecha ?? "—";
+        const hora = c.citHora ?? "—";
+        const centro = c.citCenAsiDes ?? "—";
+        return {
+            value: id,
+            label: `[${id}] ${fecha} ${hora}`,
+            hint: centro,
+        };
+    });
+    const citaId = await p.select({
+        message: "Elige la cita a cancelar",
+        options: opts,
+    });
+    if (p.isCancel(citaId))
+        return;
+    const confirma = await p.confirm({
+        message: `¿Cancelar la cita ${citaId}? Esta acción es irreversible.`,
+        initialValue: false,
+    });
+    if (p.isCancel(confirma) || !confirma) {
+        p.log.info("Cancelación abortada.");
+        return;
+    }
+    // Necesitamos el centro de la cita para cancelarla. Si no viene, abortamos:
+    // adivinarlo podría cancelar contra el centro equivocado (operación irreversible).
+    const citaObj = citas.find((c) => c.citActMedNum === citaId || c.citAutoGenCod === citaId);
+    const codCentro = citaObj?.citCenAsiCod;
+    if (!codCentro) {
+        p.log.error("No pude determinar el centro de esa cita; no la cancelo para no afectar la equivocada.");
+        return;
+    }
+    const s2 = p.spinner();
+    s2.start("Cancelando cita...");
+    try {
+        await request("POST", "eliminarCita", {
+            oriCenAsis: "1",
+            numCitaCreada: citaId,
+            codCentro,
+        });
+        s2.stop("Cita cancelada correctamente.");
+        p.log.success(`Cita ${citaId} cancelada.`);
+    }
+    catch (err) {
+        s2.stop("Error al cancelar la cita.");
+        p.log.error(String(err));
+    }
+}
+export async function runInteractiveMode() {
+    const ts = await getTokenStatus();
+    await printBanner(ts);
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        // Re-fetch ts inside loop for menu state updates after login
+        const loopTs = await getTokenStatus();
+        const opcion = await p.select({
+            message: "¿Qué quieres hacer?",
+            options: [
+                { value: "login", label: "Login", hint: "Iniciar sesión en EsSalud" },
+                { value: "perfil", label: "Mi perfil", hint: "Ver datos del asegurado" },
+                { value: "citas", label: "Mis citas", hint: "Ver citas programadas" },
+                {
+                    value: "reservar",
+                    label: "Reservar una cita",
+                    hint: "Flujo guiado: especialidad → cupo → confirmar",
+                },
+                { value: "cancelar", label: "Cancelar una cita", hint: "Seleccionar y cancelar una cita" },
+                { value: "salir", label: "Salir", hint: "Cerrar el asistente" },
+            ],
+        });
+        if (p.isCancel(opcion) || opcion === "salir") {
+            p.outro("Hasta luego.");
+            process.exit(0);
+        }
+        switch (opcion) {
+            case "login":
+                await runLogin();
+                break;
+            case "perfil":
+                await runPerfil(loopTs);
+                break;
+            case "citas":
+                await runCitas(loopTs);
+                break;
+            case "reservar":
+                await runReservar(loopTs);
+                break;
+            case "cancelar":
+                await runCancelar(loopTs);
+                break;
+        }
+    }
+}

package/dist/essalud/jwt.d.ts

@@ -0,0 +1,12 @@
+/** Matchea un JWT (header.payload.signature en base64url). */
+export declare const JWT_RE: RegExp;
+export interface JwtPayload {
+    sub?: string;
+    exp?: number;
+    iat?: number;
+    [key: string]: unknown;
+}
+/** Un JWT de EsSalud decodifica con exp o scope en el payload. */
+export declare function looksLikeEsSaludJwt(jwt: string): boolean;
+/** Decodifica el payload de un JWT (sin verificar la firma). Devuelve null si no es válido. */
+export declare function decodeJwtPayload(jwt: string): JwtPayload | null;

package/dist/essalud/jwt.js

@@ -0,0 +1,29 @@
+// Helpers puros para trabajar con JWTs de EsSalud (sin efectos secundarios).
+/** Matchea un JWT (header.payload.signature en base64url). */
+export const JWT_RE = /eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/;
+/** Un JWT de EsSalud decodifica con exp o scope en el payload. */
+export function looksLikeEsSaludJwt(jwt) {
+    try {
+        const part = jwt.split(".")[1] ?? "";
+        const json = Buffer.from(part.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8");
+        const payload = JSON.parse(json);
+        return typeof payload.exp === "number" || payload.scope != null;
+    }
+    catch {
+        return false;
+    }
+}
+/** Decodifica el payload de un JWT (sin verificar la firma). Devuelve null si no es válido. */
+export function decodeJwtPayload(jwt) {
+    try {
+        const parts = jwt.split(".");
+        if (parts.length !== 3)
+            return null;
+        const b64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+        const padded = b64 + "=".repeat((4 - (b64.length % 4)) % 4);
+        return JSON.parse(Buffer.from(padded, "base64").toString("utf-8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/essalud-bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/essalud-bin.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+/**
+ * Punto de entrada del comando global `essalud`.
+ * Sin argumentos → modo interactivo.
+ * Con argumentos → subcomandos one-shot (login, perfil, citas, etc.).
+ */
+import { Command } from "commander";
+import { makeEssaludCommand } from "./essalud/index.js";
+import { runInteractiveMode } from "./essalud/interactive.js";
+// Si no hay argumentos más allá de node + script → modo interactivo directo
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    void runInteractiveMode();
+}
+else {
+    // Reusar todos los subcomandos del comando essalud, pero en un programa raíz
+    const program = new Command();
+    program.name("essalud").description("Asistente de citas EsSalud").version("0.1.0");
+    const essaludCmd = makeEssaludCommand();
+    for (const sub of essaludCmd.commands) {
+        program.addCommand(sub);
+    }
+    program.parse(process.argv);
+}