chocolatito-code 1.0.0 → 1.2.0

package/dist/config/updater.js

@@ -0,0 +1,215 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+/**
+ * Actualizaciones solas, sin que el usuario tenga que enterarse.
+ *
+ * POR QUE HACE FALTA
+ *
+ * Se arreglo un fallo del teclado tres veces y el dueno del producto seguia
+ * viendolo, porque su `chocolatito` apuntaba al paquete publicado dos dias
+ * antes. Si al que tiene el repositorio delante le pasa eso, al que paga 16,99 $
+ * al mes le va a pasar siempre: nadie corre `npm update -g` por gusto. Un
+ * arreglo que no llega es un arreglo que no existe.
+ *
+ * COMO FUNCIONA
+ *
+ * Al arrancar se le pregunta al registro de npm cual es la ultima version. La
+ * respuesta se guarda seis horas, asi que el coste real es una peticion cada
+ * medio dia. Si hay una nueva se instala de fondo y se avisa; el cambio entra
+ * en el siguiente arranque, no a mitad de sesion (cambiarle el codigo por
+ * debajo a un proceso vivo es como se rompen las cosas de verdad).
+ *
+ * LAS TRES COSAS QUE NUNCA HACE
+ *
+ * 1. No toca una instalacion de desarrollo. Si `chocolatito` sale de un
+ *    `npm link` sobre el repositorio, instalar encima le borraria el trabajo al
+ *    que lo esta escribiendo. Se detecta y se calla.
+ * 2. No bloquea el arranque. Si el registro no contesta, no contesta: la sesion
+ *    ya va por su cuenta y el aviso aparece cuando llegue, o no aparece.
+ * 3. No insiste. Si no hay permiso para escribir en la carpeta global, se dice
+ *    una vez el comando que hay que correr y se deja en paz.
+ *
+ * Para apagarlo del todo: CHOCOLATITO_SIN_ACTUALIZAR=1.
+ */
+const PAQUETE = "chocolatito-code";
+const REGISTRO = `https://registry.npmjs.org/${PAQUETE}/latest`;
+/** Cada cuanto se le pregunta al registro. Doce veces al dia no aporta nada. */
+export const HORAS_ENTRE_COMPROBACIONES = 6;
+/** Lo que se espera al registro. Pasado esto, la sesion vale mas que el aviso. */
+const TIMEOUT_MS = 4000;
+const FICHERO_CACHE = path.join(os.homedir(), ".chocolatito", "actualizacion.json");
+/**
+ * Compara dos versiones de tipo 1.2.3.
+ *
+ * No se usa una libreria por una razon concreta: `semver` arrastra dependencias
+ * y esto se ejecuta en el arranque de un CLI. Lo que si se respeta es lo unico
+ * que importa aqui: una preversion (1.1.0-beta.1) NUNCA es mas nueva que la
+ * final del mismo numero, o el usuario acabaria bajando a una beta sin pedirlo.
+ */
+export function esMasNueva(candidata, actual) {
+    const trocear = (v) => {
+        const [nucleo, pre] = String(v || "").trim().split("-", 2);
+        const partes = nucleo.split(".").map((n) => Number.parseInt(n, 10));
+        return {
+            nums: [partes[0] || 0, partes[1] || 0, partes[2] || 0],
+            pre: pre ?? null,
+        };
+    };
+    const a = trocear(candidata);
+    const b = trocear(actual);
+    for (let i = 0; i < 3; i++) {
+        if (a.nums[i] > b.nums[i])
+            return true;
+        if (a.nums[i] < b.nums[i])
+            return false;
+    }
+    // Mismo numero: solo gana la candidata si la actual es preversion y ella no.
+    return a.pre === null && b.pre !== null;
+}
+/**
+ * De donde sale el `chocolatito` que se esta ejecutando.
+ *
+ * Si al lado del `dist` hay un `.git` o un `src`, esto es el repositorio, no un
+ * paquete instalado: `npm link` o `node dist/index.js` a pelo. Instalar encima
+ * seria pisarle el codigo al que lo esta escribiendo.
+ */
+export function esInstalacionDeDesarrollo(raizDelPaquete) {
+    try {
+        return (fs.existsSync(path.join(raizDelPaquete, ".git")) ||
+            fs.existsSync(path.join(raizDelPaquete, "src")));
+    }
+    catch {
+        return false;
+    }
+}
+export function leerCache(fichero = FICHERO_CACHE) {
+    try {
+        return JSON.parse(fs.readFileSync(fichero, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function guardarCache(datos, fichero = FICHERO_CACHE) {
+    try {
+        fs.mkdirSync(path.dirname(fichero), { recursive: true });
+        fs.writeFileSync(fichero, JSON.stringify(datos, null, 2), "utf-8");
+    }
+    catch {
+        // Sin cache se pregunta en cada arranque: molesto, no grave. No es motivo
+        // para romperle la sesion a nadie.
+    }
+}
+/** Si toca preguntar al registro. Un reloj adelantado no deja de comprobar nunca. */
+export function tocaComprobar(cache, ahora) {
+    const ultima = cache.comprobadoEn;
+    if (typeof ultima !== "number" || !Number.isFinite(ultima))
+        return true;
+    const transcurrido = ahora - ultima;
+    // El valor absoluto cubre el reloj hacia atras: una marca en el futuro
+    // significa que algo esta mal, y lo seguro es volver a preguntar.
+    return Math.abs(transcurrido) >= HORAS_ENTRE_COMPROBACIONES * 60 * 60 * 1000;
+}
+/** Le pregunta al registro. Devuelve null si no contesta a tiempo o no se entiende. */
+export async function ultimaVersionPublicada(url = REGISTRO) {
+    try {
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+            headers: { accept: "application/json" },
+        });
+        if (!res.ok)
+            return null;
+        const datos = (await res.json());
+        const v = String(datos?.version ?? "");
+        return /^\d+\.\d+\.\d+/.test(v) ? v : null;
+    }
+    catch {
+        // Sin red, con proxy raro, o el registro caido. Nada de esto es problema
+        // del usuario y nada de esto merece un mensaje de error.
+        return null;
+    }
+}
+/**
+ * Instala la version nueva en la carpeta global.
+ *
+ * Se hace con `npm install -g`, que es como se instalo, en vez de inventarse
+ * una descarga: asi funciona igual con nvm, con volta y con la instalacion de
+ * Windows, que ponen la carpeta global en sitios distintos.
+ */
+export function instalar(version, ejecutar = spawnNpm) {
+    return ejecutar(["install", "-g", `${PAQUETE}@${version}`]).then((salida) => {
+        if (salida.codigo === 0) {
+            return {
+                ok: true,
+                mensaje: `Actualizado a ${version}. Entra al reiniciar chocolatito.`,
+            };
+        }
+        // El caso que de verdad pasa: la carpeta global es de administrador o de
+        // otro usuario. Decir "fallo la actualizacion" no ayuda; decir el comando si.
+        const texto = `${salida.salida}`.toLowerCase();
+        const sinPermiso = texto.includes("eacces") || texto.includes("eperm") || texto.includes("acceso denegado");
+        return {
+            ok: false,
+            mensaje: sinPermiso
+                ? `Hay una version nueva (${version}) pero no hay permiso para instalarla. Ejecuta: npm i -g ${PAQUETE}@latest`
+                : `No se pudo instalar la ${version} sola. Ejecuta: npm i -g ${PAQUETE}@latest`,
+        };
+    });
+}
+function spawnNpm(args) {
+    return new Promise((resolve) => {
+        // shell:true porque en Windows `npm` es un .cmd y sin shell no se encuentra.
+        const p = spawn("npm", args, { shell: true, windowsHide: true });
+        let salida = "";
+        p.stdout?.on("data", (d) => (salida += d));
+        p.stderr?.on("data", (d) => (salida += d));
+        p.on("error", (e) => resolve({ codigo: 1, salida: String(e?.message || e) }));
+        p.on("close", (codigo) => resolve({ codigo: codigo ?? 1, salida }));
+    });
+}
+/**
+ * El paso completo: comprobar, y si procede instalar.
+ *
+ * Devuelve lo que hay que ensenarle al usuario, o cadena vacia si no hay nada.
+ * No imprime nada por su cuenta: quien llama decide cuando y como, que en un
+ * CLI con un prompt dibujado no es lo mismo escribir ahora que dentro de un
+ * segundo.
+ */
+export async function comprobarActualizacion(ajustes) {
+    if (!ajustes.forzar && process.env.CHOCOLATITO_SIN_ACTUALIZAR === "1")
+        return "";
+    const desarrollo = esInstalacionDeDesarrollo(ajustes.raizDelPaquete);
+    if (desarrollo && !ajustes.forzar)
+        return "";
+    const cache = leerCache();
+    if (!ajustes.forzar && !tocaComprobar(cache, ajustes.ahora)) {
+        // Ya se pregunto hace poco. Si en su dia se vio una version nueva y sigue
+        // sin instalarse (sin permisos, por ejemplo), se recuerda sin volver a la red.
+        const guardada = cache.ultima;
+        if (guardada && esMasNueva(guardada, ajustes.versionActual) && cache.avisadaDe !== guardada) {
+            return `Hay una version nueva (${guardada}). Ejecuta: npm i -g ${PAQUETE}@latest`;
+        }
+        return "";
+    }
+    const ultima = await ultimaVersionPublicada();
+    guardarCache({ ...cache, comprobadoEn: ajustes.ahora, ultima: ultima ?? cache.ultima });
+    if (!ultima)
+        return ajustes.forzar ? "No se pudo consultar el registro de npm. ¿Hay conexion?" : "";
+    if (!esMasNueva(ultima, ajustes.versionActual)) {
+        return ajustes.forzar ? `Ya vas por la ultima version (${ajustes.versionActual}).` : "";
+    }
+    if (desarrollo) {
+        // Solo con /actualizar se llega aqui, y aun asi no se instala: el aviso es
+        // util (te dice que lo publicado va por delante de lo que tienes), pisar el
+        // repositorio no.
+        return `Publicada la ${ultima} y tu vas por la ${ajustes.versionActual}, pero esto es una instalacion de desarrollo: no se toca. Publica desde el repositorio.`;
+    }
+    if (ajustes.automatico === false) {
+        return `Hay una version nueva (${ultima}). Ejecuta: npm i -g ${PAQUETE}@latest`;
+    }
+    const res = await instalar(ultima);
+    guardarCache({ ...leerCache(), comprobadoEn: ajustes.ahora, ultima, avisadaDe: res.ok ? ultima : undefined });
+    return res.mensaje;
+}

package/dist/hooks/manager.js

@@ -1,8 +1,96 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import chalk from "chalk";
 import { execa } from "execa";
 const DEFAULT_TIMEOUT_MS = 30_000;
+/**
+ * EL SHELL DE LOS HOOKS, RESUELTO A UNA RUTA QUE EXISTE
+ *
+ * Antes esto era una sola linea: `shell: usaPowerShell ? "powershell.exe" :
+ * "/bin/bash"`. Ese "/bin/bash" literal no existe en Windows (Git Bash se
+ * instala en "C:\Program Files\Git\bin\bash.exe"; /bin/bash es una ruta interna
+ * de MSYS que el spawn de Windows no resuelve) y tampoco en una imagen Alpine,
+ * NixOS o slim, donde el unico shell es /bin/sh.
+ *
+ * Y no se notaba: con `reject: false` execa no lanza excepcion cuando el shell
+ * no existe, devuelve exitCode undefined con stdout y stderr vacios. O sea que
+ * un hook PreToolUse de deny quedaba descartado por el `if (!salida) continue` y
+ * la accion peligrosa se ejecutaba: el fallo silencioso en la direccion
+ * insegura, que es la peor de las dos.
+ */
+const shellsResueltos = new Map();
+function primeraExistente(rutas) {
+    return rutas.find((r) => !!r && fs.existsSync(r));
+}
+/** Busca un ejecutable por el PATH sin lanzar procesos (nada de `which`). */
+function buscarEnPath(nombres, filtroDir) {
+    const dirs = (process.env.PATH || process.env.Path || "")
+        .split(path.delimiter)
+        .map((d) => d.trim().replace(/^"|"$/g, ""))
+        .filter(Boolean)
+        .filter((d) => !filtroDir || filtroDir(d));
+    for (const nombre of nombres) {
+        for (const dir of dirs) {
+            const candidato = path.join(dir, nombre);
+            if (fs.existsSync(candidato))
+                return candidato;
+        }
+    }
+    return undefined;
+}
+function buscarBash() {
+    if (process.platform !== "win32") {
+        // /bin/sh va al final a proposito: en Alpine, NixOS o una imagen slim es el
+        // unico que hay, y un hook de una linea funciona igual. Preferir un shell
+        // que si existe es mejor que no ejecutar la politica del usuario.
+        return (primeraExistente(["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash", "/bin/sh", "/usr/bin/sh"]) ?? null);
+    }
+    const bases = [
+        process.env["ProgramFiles"],
+        process.env["ProgramW6432"],
+        process.env["ProgramFiles(x86)"],
+        process.env["LOCALAPPDATA"] ? path.join(process.env["LOCALAPPDATA"], "Programs") : undefined,
+    ].filter((b) => !!b);
+    const git = primeraExistente(bases.map((b) => path.join(b, "Git", "bin", "bash.exe")));
+    if (git)
+        return git;
+    // Ultimo recurso, el PATH, saltandose System32\bash.exe: ese es el lanzador de
+    // WSL, que ve otro sistema de archivos y otras rutas. Un hook que crea estar
+    // mirando el proyecto miraria otra cosa.
+    return buscarEnPath(["bash.exe"], (dir) => !/system32\\?$/i.test(dir)) ?? null;
+}
+function buscarPowerShell() {
+    if (process.platform === "win32") {
+        const sysroot = process.env["SystemRoot"] || "C:\\Windows";
+        return (primeraExistente([path.join(sysroot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe")]) ??
+            buscarEnPath(["pwsh.exe", "powershell.exe"]) ??
+            null);
+    }
+    // Fuera de Windows solo tiene sentido si el usuario pidio "powershell" a mano.
+    return buscarEnPath(["pwsh"]) ?? null;
+}
+function resolverShell(tipo) {
+    if (shellsResueltos.has(tipo))
+        return shellsResueltos.get(tipo);
+    const ruta = tipo === "powershell" ? buscarPowerShell() : buscarBash();
+    shellsResueltos.set(tipo, ruta);
+    return ruta;
+}
+function recortar(texto, max = 400) {
+    const limpio = texto.trim().replace(/\s+$/g, "");
+    return limpio.length > max ? `${limpio.slice(0, max)}…` : limpio;
+}
+/** Por que no salio bien, en una linea, para poder contarselo al usuario. */
+function motivoDelFallo(res) {
+    if (res?.timedOut)
+        return "agoto el tiempo limite";
+    if (res?.exitCode === undefined || res?.exitCode === null) {
+        const detalle = recortar(String(res?.shortMessage || res?.message || ""), 160).split("\n")[0];
+        return detalle ? `no llego a ejecutarse (${detalle})` : "no llego a ejecutarse";
+    }
+    return `codigo de salida ${res.exitCode}`;
+}
 export class HookManager {
     config = {};
     disabled = false;
@@ -113,17 +201,63 @@ export class HookManager {
         });
         const decision = {};
         const contextos = [];
+        /**
+         * Un hook que no arranca, revienta o se cuelga NO bloquea (solo el codigo 2
+         * bloquea, igual que en Claude Code), pero TIENE que verse. Antes se caia
+         * por el `if (!salida) continue` de mas abajo y la politica quedaba muerta
+         * sin una sola linea de aviso: el usuario seguia creyendo que su guardia
+         * estaba puesto. Se imprime aqui, y no en el llamador, porque a run() la
+         * llaman el bucle, la puerta de herramientas y los subagentes, y solo uno de
+         * ellos pinta systemMessage. Por eso el aviso NO se mete ademas en
+         * systemMessage: el bucle lo imprimiria otra vez y el usuario veria el mismo
+         * fallo dos veces.
+         */
+        const avisar = (texto) => {
+            contextos.push(`[${texto}]`);
+            console.error(chalk.yellow(`\n⚠ ${texto}`));
+        };
+        /**
+         * En PostToolUse la herramienta YA se ejecuto: "bloquear" no puede abortar
+         * nada, solo devolverle el motivo al modelo para que lo corrija. Y era justo
+         * eso lo que no pasaba: el bloqueo se empaquetaba en permissionDecision /
+         * permissionDecisionReason y se volvia de inmediato, mientras que el unico
+         * consumidor de PostToolUse lee additionalContext. Resultado: el atajo que
+         * documenta el propio proyecto —salir con codigo 2, o imprimir
+         * decision:"block"— era un agujero negro. El hook se ejecutaba, salia en
+         * /hooks como configurado, y ni el usuario ni el modelo veian una palabra.
+         *
+         * Devuelve true cuando hay que cortar la cadena, que solo tiene sentido
+         * antes de ejecutar. En PostToolUse se sigue: los demas hooks —linters,
+         * tests— tambien tienen algo que decir sobre lo que ya ha pasado.
+         */
+        const esPost = event === "PostToolUse";
+        const anotarBloqueo = (motivo) => {
+            decision.permissionDecision = "deny";
+            decision.permissionDecisionReason = motivo;
+            if (!esPost)
+                return true;
+            contextos.push(`BLOQUEO del hook PostToolUse: ${motivo}`);
+            return false;
+        };
         for (const hook of hooks) {
             try {
-                const usaPowerShell = hook.shell === "powershell" || (hook.shell !== "bash" && process.platform === "win32");
+                const tipo = hook.shell === "powershell" || (hook.shell !== "bash" && process.platform === "win32")
+                    ? "powershell"
+                    : "bash";
+                const shell = resolverShell(tipo);
+                if (!shell) {
+                    avisar(`El hook ${event} "${hook.command}" NO se ejecuto: no hay ningun ${tipo} en este sistema. ` +
+                        "La regla que impone no se esta aplicando.");
+                    continue;
+                }
                 // PowerShell NO propaga el codigo de salida del programa que ejecuta:
                 // powershell.exe sale con 0 aunque el hook haya salido con 2. Sin este
                 // "exit $LASTEXITCODE", el bloqueo por codigo de salida no funcionaba en
                 // Windows y el hook parecia estar aprobando siempre.
-                const comando = usaPowerShell ? `${hook.command}; exit $LASTEXITCODE` : hook.command;
+                const comando = tipo === "powershell" ? `${hook.command}; exit $LASTEXITCODE` : hook.command;
                 const res = await execa(comando, {
                     cwd: this.cwd,
-                    shell: usaPowerShell ? "powershell.exe" : "/bin/bash",
+                    shell,
                     input,
                     timeout: hook.timeout ? hook.timeout * 1000 : DEFAULT_TIMEOUT_MS,
                     reject: false,
@@ -132,10 +266,19 @@ export class HookManager {
                 // Codigo 2 = bloqueo. No se puede sobrescribir con JSON: es el atajo
                 // para un hook de una linea que solo quiere decir "aqui no".
                 if (res.exitCode === 2) {
-                    decision.permissionDecision = "deny";
-                    decision.permissionDecisionReason =
-                        (res.stderr || res.stdout || "").trim() || `El hook "${hook.command}" bloqueo la accion.`;
-                    return decision;
+                    const motivo = (res.stderr || res.stdout || "").trim() || `El hook "${hook.command}" bloqueo la accion.`;
+                    if (anotarBloqueo(motivo))
+                        return decision;
+                    continue;
+                }
+                // Cualquier otro final anormal (script inexistente, error de sintaxis,
+                // timeout, shell que no arranco) se cuenta. No bloquea, pero se dice:
+                // ese silencio era el fallo, no el hecho de dejar pasar.
+                if (res.exitCode !== 0) {
+                    const detalle = recortar(String(res.stderr || res.stdout || ""));
+                    avisar(`El hook ${event} "${hook.command}" fallo (${motivoDelFallo(res)}) y su regla no se aplico.` +
+                        (detalle ? `\n  ${detalle.split("\n").join("\n  ")}` : ""));
+                    continue;
                 }
                 const salida = (res.stdout || "").trim();
                 if (!salida)
@@ -151,14 +294,16 @@ export class HookManager {
                     }
                     const esp = parsed.hookSpecificOutput || {};
                     if (parsed.decision === "block") {
-                        decision.permissionDecision = "deny";
-                        decision.permissionDecisionReason = parsed.reason || "Bloqueado por un hook.";
-                        return decision;
+                        if (anotarBloqueo(parsed.reason || "Bloqueado por un hook."))
+                            return decision;
+                        if (parsed.systemMessage)
+                            decision.systemMessage = parsed.systemMessage;
+                        continue;
                     }
                     if (esp.permissionDecision === "deny") {
-                        decision.permissionDecision = "deny";
-                        decision.permissionDecisionReason = esp.permissionDecisionReason || "Bloqueado por un hook.";
-                        return decision;
+                        if (anotarBloqueo(esp.permissionDecisionReason || "Bloqueado por un hook."))
+                            return decision;
+                        continue;
                     }
                     // "allow" no gana sobre un "deny" posterior: por eso no se corta aqui.
                     if (esp.permissionDecision && !decision.permissionDecision) {
@@ -178,7 +323,7 @@ export class HookManager {
                 }
             }
             catch (err) {
-                contextos.push(`[hook "${hook.command}" fallo: ${err?.message || err}]`);
+                avisar(`El hook ${event} "${hook.command}" fallo y su regla no se aplico: ${err?.message || err}`);
             }
         }
         if (contextos.length > 0)