chocolatito-code 1.0.0 → 1.2.0

package/dist/config/permissions.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { isBrowserAttached } from "../tools/browserSession.js";
 /**
  * Acciones de SOLO OBSERVAR de cada herramienta de control.
  *
@@ -30,19 +31,131 @@ const OBSERVE_ONLY = {
 };
 /** Herramientas que conducen el ordenador o el navegador del usuario. */
 const CONTROL_TOOLS = Object.keys(OBSERVE_ONLY);
+/**
+ * Herramientas cuyas acciones "observadoras" pueden ARRANCAR el navegador.
+ *
+ * browserCdp llama a ensureBrowser() en todas las acciones menos "close", y
+ * ensureBrowser, si no encuentra un Chrome escuchando el puerto de depuracion,
+ * lo lanza con spawn(detached) y lo deja vivo cuando la CLI termina. Con
+ * useSystemProfile lo lanza sobre el perfil REAL del usuario —sus cookies y sus
+ * sesiones— con el 9222 abierto en 127.0.0.1, que cualquier proceso local puede
+ * conducir. Clasificar eso como "solo observar" no lo hacia inofensivo: lo hacia
+ * silencioso, y ademas lo colaba en modo plan.
+ *
+ * La regla sigue siendo "mirar es gratis", pero mirar solo es gratis cuando no
+ * hay nada que arrancar: con una sesion CDP ya viva, snapshot y tabs no hacen
+ * mas que leer.
+ */
+const BROWSER_TOOLS = new Set(["browser", "browser_live"]);
 /** Herramientas que modifican el disco o el repositorio. */
 const MODIFYING_TOOLS = ["edit_file", "write_file", "delete_file", "move_copy_file", "git_commit"];
+/**
+ * Argumentos con ruta de cada herramienta que escribe en disco.
+ *
+ * Sirve para lo unico que la tabla no comprobaba en ningun sitio: si lo que se
+ * va a tocar cae dentro del proyecto o en cualquier otro punto del disco.
+ */
+const RUTAS_DE_ESCRITURA = {
+    write_file: ["path"],
+    edit_file: ["path"],
+    delete_file: ["path"],
+    move_copy_file: ["sourcePath", "destinationPath"],
+    create_image: ["outputPath"],
+};
+/**
+ * Una ruta esta fuera del proyecto si, resuelta, no cuelga de la raiz.
+ *
+ * Vale para rutas absolutas (C:\Windows\..., ~/.ssh/...) y para las relativas
+ * con ".." que salen del arbol, que es la forma que no se ve venir leyendo la
+ * llamada por encima. path.relative en Windows ya compara sin distinguir
+ * mayusculas y devuelve la ruta entera cuando cambia de unidad.
+ */
+export function isOutsideProject(projectRoot, target) {
+    if (typeof target !== "string" || !target.trim())
+        return false;
+    const raiz = path.resolve(projectRoot);
+    const destino = path.resolve(raiz, target);
+    const rel = path.relative(raiz, destino);
+    if (rel === "")
+        return false;
+    return rel.startsWith("..") || path.isAbsolute(rel);
+}
+/**
+ * create_image mete dos cosas muy distintas en el mismo argumento: un SVG, que
+ * solo se escribe en disco, o codigo Python, que se guarda en un .py y se lanza
+ * con `python`. Quien lo distingue es esta funcion, y la usan tanto la
+ * herramienta como la tabla de permisos: si cada una detectara el SVG a su
+ * manera, bastaria una diferencia entre las dos para colar codigo por la rama
+ * que no pregunta.
+ */
+export function isSvgSource(script) {
+    const s = typeof script === "string" ? script.trim() : "";
+    return s.startsWith("<svg") || s.startsWith("<?xml");
+}
+/**
+ * create_image con Python es ejecucion de codigo arbitrario con nombre de
+ * herramienta de dibujo: el contenido que escriba el modelo acaba corriendo
+ * entero, no solo la parte que pinta. La especificacion la clasifica como
+ * `exec`, igual que run_command; la tabla la trataba como una escritura de
+ * archivo corriente porque clasificaba por nombre y este no salia en ninguna
+ * lista.
+ */
+function isCodeGeneration(toolName, args) {
+    return toolName === "create_image" && !isSvgSource(args?.generatorScript);
+}
 /** Solo lee estado, no toca nada. */
 function isObserveOnly(toolName, args) {
     const set = OBSERVE_ONLY[toolName];
     if (!set)
         return false;
-    return set.has(String(args?.action ?? ""));
+    if (!set.has(String(args?.action ?? "")))
+        return false;
+    // Sin sesion CDP viva, hasta el "attach" mas inocente puede acabar en un
+    // spawn(chrome.exe, --remote-debugging-port) que sobrevive a la sesion. Eso no
+    // es observar: es arrancar un proceso, y se pregunta.
+    if (BROWSER_TOOLS.has(toolName) && !isBrowserAttached())
+        return false;
+    return true;
 }
 /** Conduce de verdad el ordenador o el navegador: clics, teclado, navegacion, JS. */
 function isActuation(toolName, args) {
     return CONTROL_TOOLS.includes(toolName) && !isObserveOnly(toolName, args);
 }
+/**
+ * Prefijo de git que admite opciones globales antes del subcomando.
+ *
+ * El regex anterior exigia el subcomando pegado a "git", asi que
+ * "git -C otra/ruta checkout -- ." no lo veia nadie: bastaba con decirle a git
+ * en que repositorio trabajar para saltarse el filtro entero.
+ */
+const GIT = String.raw `\bgit(?:\s+(?:-[cC]\s+\S+|--[\w-]+(?:=\S+)?|-[a-zA-Z]))*\s+`;
+/**
+ * Git que destruye trabajo o pisa el remoto.
+ *
+ * Antes esto era un solo regex con las alternativas metidas en un grupo y un
+ * \b de cierre fuera: /\bgit\s+(...|restore\s+\.|checkout\s+\.|...)\b/. Como
+ * "restore \." y "checkout \." acaban en punto, que no es caracter de palabra,
+ * ese \b final NUNCA casaba y las dos ramas estaban muertas. Resultado: la regla
+ * quedaba del reves, "git checkout .gitignore" pedia dialogo (ahi el \b si
+ * encontraba frontera) y "git checkout .", que borra el arbol entero, se
+ * ejecutaba sin preguntar. Es el mismo fallo que el comentario de "format c:"
+ * dice haber arreglado, dejado intacto aqui.
+ *
+ * Ahora es una regla por forma destructiva, sin \b traicioneros.
+ */
+const GIT_DESTRUCTIVO = [
+    new RegExp(GIT + String.raw `reset\s+--hard`, "i"),
+    new RegExp(GIT + String.raw `clean\s+-[a-z]*[fxd]`, "i"),
+    new RegExp(GIT + String.raw `push\b[^\n]*(\s-f\b|--force)`, "i"),
+    new RegExp(GIT + String.raw `branch\s+-D\b`, "i"),
+    // "restore" existe justamente para descartar cambios del arbol de trabajo: no
+    // hay forma inocente de usarlo, ni siquiera --staged, que deshace el stage.
+    new RegExp(GIT + String.raw `restore\b`, "i"),
+    // "checkout" tambien cambia de rama, que no destruye nada. Lo que borra
+    // trabajo es el pathspec: un "." pelado, un "*", cualquier cosa detras de
+    // "--" (incluido el "git checkout HEAD -- ." de toda la vida) o un -f.
+    new RegExp(GIT + String.raw `checkout\b[^\n]*(\s--(\s|$)|\s\.(\s|$)|\s\*(\s|$)|\s-f\b|\s--force\b)`, "i"),
+];
 /**
  * Detecta comandos destructivos o de alto riesgo que siempre deben pedir confirmación.
  * Comandos seguros de desarrollo (python, npm, pytest, tsc, git status, etc.) no interrumpen al usuario.
@@ -54,13 +167,13 @@ export function isDangerousCommand(command) {
     // 1. Borrado recursivo o forzado de archivos/directorios.
     //    Ojo con \b al final: "format c:" termina en ':', que no es caracter de
     //    palabra, asi que un \b de cierre nunca casa y el patron no servia de nada.
-    if (/\b(rm\s+[^\n]*-[^\n]*[rf]|rmdir\s+[^\n]*\/s|\brd\s+[^\n]*\/s|del\s+[^\n]*\/[fsq]|Remove-Item\s+[^\n]*-Recurse|mkfs)\b/i.test(cmd) ||
+    if (/\b(rm\s+[^\n]*-[^\n]*[rf]|rmdir\s+[^\n]*\/s|\brd\s+[^\n]*\/s|del\s+[^\n]*\/[fsq]|Remove-Item\s+[^\n]*-r(?:e(?:c(?:u(?:r(?:s(?:e)?)?)?)?)?)?\b|mkfs)\b/i.test(cmd) ||
         /\bformat\s+[a-z]:/i.test(cmd) ||
         /\bdd\s+[^\n]*\bof=/i.test(cmd)) {
         return true;
     }
     // 2. Operaciones destructivas de Git (pérdida irreversible de trabajo o sobreescritura remota)
-    if (/\bgit\s+(reset\s+--hard|clean\s+-[fxd]+|push\s+[^\n]*(-f\b|--force)|restore\s+\.|checkout\s+\.|branch\s+-D\b)\b/i.test(cmd)) {
+    if (GIT_DESTRUCTIVO.some((re) => re.test(cmd))) {
         return true;
     }
     // 3. Terminación de procesos y apagado del sistema
@@ -95,13 +208,91 @@ export function isDangerousCommand(command) {
     }
     return false;
 }
+/**
+ * Cuanto restringe cada modo. Sirve para decidir si una capa de settings sube o
+ * baja el liston: el proyecto solo puede subirlo.
+ */
+const RESTRICCION = {
+    bypass: 0,
+    acceptEdits: 1,
+    default: 2,
+    plan: 3,
+};
+/**
+ * Marcas de "aqui empieza otro comando".
+ *
+ * La lista anterior era /[;&|]/ y se dejaba fuera el salto de linea, que en
+ * PowerShell y en bash separa sentencias igual que un punto y coma. runCommand
+ * le pasa al shell la cadena entera de una pieza, asi que con un patron tan
+ * inocente como "npm" guardado (loop.ts guarda solo el primer token del comando
+ * aprobado: aceptar una vez `npm publish` guarda "npm"), esto se ejecutaba
+ * entero y sin un solo dialogo:
+ *
+ *     npm test
+ *     Remove-Item -Recurse -Force C:\Users\yo\proyecto
+ *
+ * Van tambien el retorno de carro y las dos formas de sustitucion de comandos,
+ * `...` y $(...), que lanzan un segundo proceso sin necesitar separador.
+ */
+const ENCADENADO = /[;&|\r\n`]|\$\(/;
+/** Trocea la linea en sentencias sueltas. Un deny tiene que mirarlas todas. */
+function sentencias(command) {
+    return command
+        .split(/[;\r\n]+|&&|\|\||[|&]/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/**
+ * Piezas que por si solas no dicen que hace el comando: hay que mirar la
+ * siguiente. "npm run" puede ser cualquier cosa; "npm run build" ya no.
+ */
+const DESPACHADORES = new Set(["run", "run-script", "exec", "x", "dlx", "workspace"]);
+/**
+ * Firma con la que se recuerda un comando aprobado.
+ *
+ * El bucle guardaba command.split(" ")[0], o sea solo el binario: aprobar un
+ * "git status" dejaba escrito el patron "git" y, como el allow autoriza por
+ * prefijo, a partir de ahi pasaban sin dialogo tambien "git push --force" y
+ * "git reset --hard", en todas las sesiones del proyecto.
+ *
+ * La firma es binario + subcomando ("git status", "npm run build"). Si el
+ * comando no trae subcomando sino opciones se guarda entero: ensancharlo hasta
+ * el binario es justo el fallo que se esta arreglando.
+ */
+export function commandSignature(command) {
+    if (!command || typeof command !== "string")
+        return "";
+    // Lo encadenado detras de ; && | no forma parte de lo que el usuario aprobo.
+    const primero = command.trim().split(/[;&|\r\n]/)[0].trim();
+    const partes = primero.split(/\s+/).filter(Boolean);
+    if (partes.length === 0)
+        return "";
+    const firma = [partes[0]];
+    for (let i = 1; i < partes.length && firma.length < 3; i++) {
+        const pieza = partes[i];
+        // Una opcion ya no describe que hace el comando; el subcomando, si.
+        if (pieza.startsWith("-"))
+            break;
+        firma.push(pieza);
+        if (!DESPACHADORES.has(pieza))
+            break;
+    }
+    // Sin subcomando se guarda el comando entero. Reducirlo al binario es
+    // exactamente lo que dejaba "git" autorizando cualquier git.
+    if (firma.length === 1 && partes.length > 1)
+        return primero;
+    return firma.join(" ");
+}
 export class PermissionManager {
     mode = "default";
     allowPatterns = new Set();
     denyPatterns = new Set();
     settingsFilePath;
+    /** Raiz del proyecto: el limite dentro del cual escribir no interrumpe. */
+    projectRoot;
     constructor(initialMode = "default", cwd = process.cwd()) {
         this.mode = initialMode;
+        this.projectRoot = path.resolve(cwd);
         this.settingsFilePath = path.join(cwd, ".chocolatito", "settings.json");
         this.loadSettings();
     }
@@ -111,7 +302,7 @@ export class PermissionManager {
         if (fs.existsSync(globalPath)) {
             try {
                 const parsed = JSON.parse(fs.readFileSync(globalPath, "utf-8"));
-                this.applySettings(parsed);
+                this.applySettings(parsed, "global");
             }
             catch { }
         }
@@ -119,14 +310,33 @@ export class PermissionManager {
         if (fs.existsSync(this.settingsFilePath)) {
             try {
                 const parsed = JSON.parse(fs.readFileSync(this.settingsFilePath, "utf-8"));
-                this.applySettings(parsed);
+                this.applySettings(parsed, "proyecto");
             }
             catch { }
         }
     }
-    applySettings(settings) {
-        if (settings.permissions?.mode) {
-            this.mode = settings.permissions.mode;
+    /**
+     * Aplica una capa de settings.
+     *
+     * La capa del proyecto solo puede RESTRINGIR. Antes se aplicaba despues de la
+     * global y fijaba el modo sin mas, asi que un repositorio clonado con
+     * {"permissions":{"mode":"bypass"}} en su .chocolatito/settings.json apagaba
+     * los dialogos en la maquina de quien lo abriera, sin decir nada. Elevar
+     * permisos es cosa del usuario: su settings global o la linea de comandos.
+     */
+    applySettings(settings, origen) {
+        const modo = settings.permissions?.mode;
+        if (modo) {
+            if (origen === "global" || RESTRICCION[modo] >= RESTRICCION[this.mode]) {
+                this.mode = modo;
+            }
+            else {
+                // Se avisa por pantalla: un intento de elevacion silencioso es
+                // exactamente lo que hay que ver, no lo que hay que tragarse.
+                console.warn(`Aviso de permisos: el settings.json de este proyecto pide el modo "${modo}" y se ignora. ` +
+                    `Un repositorio no puede elevar los permisos de tu maquina; sigues en "${this.mode}". ` +
+                    `Si lo quieres de verdad, ponlo en tu settings global o cambia de modo con shift+tab.`);
+            }
         }
         if (settings.permissions?.allowPatterns) {
             settings.permissions.allowPatterns.forEach((p) => this.allowPatterns.add(p));
@@ -140,9 +350,21 @@ export class PermissionManager {
         const dir = path.dirname(this.settingsFilePath);
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir, { recursive: true });
+        // El modo no se vuelca desde memoria. El usuario puede estar en bypass
+        // temporal (shift+tab) y dejarlo escrito en un fichero que se commitea es
+        // justo el agujero de arriba, servido por nosotros mismos. Se respeta lo que
+        // ya hubiera en el fichero y punto.
+        let modoEnDisco;
+        try {
+            if (fs.existsSync(this.settingsFilePath)) {
+                const previo = JSON.parse(fs.readFileSync(this.settingsFilePath, "utf-8"));
+                modoEnDisco = previo.permissions?.mode;
+            }
+        }
+        catch { }
         const config = {
             permissions: {
-                mode: this.mode,
+                ...(modoEnDisco ? { mode: modoEnDisco } : {}),
                 allowPatterns: Array.from(this.allowPatterns),
                 denyPatterns: Array.from(this.denyPatterns),
             },
@@ -170,13 +392,42 @@ export class PermissionManager {
         if (toolName === "run_command") {
             return "El modo plan es de solo lectura: no se ejecutan comandos. Investiga con view_file, grep_search y list_dir.";
         }
+        // Lanzar Chrome es arrancar un proceso, no mirar: en un modo que promete
+        // solo lectura no cabe, aunque la accion pedida se llame "snapshot".
+        if (BROWSER_TOOLS.has(toolName) && !isBrowserAttached()) {
+            return (`El modo plan es de solo lectura: no hay ningun Chrome enganchado, asi que "${toolName}" tendria que ` +
+                "lanzarlo con el puerto de depuracion abierto. Sobre un navegador ya enganchado si puedes mirar.");
+        }
         if (isActuation(toolName, args)) {
             return (`El modo plan es de solo lectura: "${toolName}" puede mirar (snapshot, screenshot, tabs) ` +
                 "pero no actuar sobre el ordenador ni el navegador del usuario.");
         }
+        // Las dos ramas de create_image tienen efecto en disco: la de Python ejecuta
+        // el script y la de SVG escribe el archivo en cualquier ruta absoluta. Sin
+        // esto, el modo plan era de solo lectura para write_file y run_command pero
+        // no para la herramienta que hace las dos cosas a la vez.
+        if (toolName === "create_image") {
+            return isCodeGeneration(toolName, args)
+                ? 'El modo plan es de solo lectura: "create_image" ejecuta el script generador con python. Descríbelo en el plan y ejecútalo al salir del modo plan.'
+                : 'El modo plan es de solo lectura: "create_image" escribe el archivo en disco.';
+        }
         return null;
     }
-    requiresConfirmation(toolName, args) {
+    /**
+     * `cwd` es contra que directorio se mide "dentro del proyecto". Tiene que ser
+     * el MISMO que recibe executeToolCall, porque es contra el que las
+     * herramientas resuelven las rutas relativas: si aqui se midiera contra la
+     * raiz de la sesion y el bucle escribiera desde otro directorio (currentCwd
+     * cambia con cd), un "x.txt" saldria "dentro" en la comprobacion y caeria
+     * fuera al escribirse. Sin argumento se usa la raiz con la que se construyo.
+     */
+    requiresConfirmation(toolName, args, cwd) {
+        // El deny va lo primero, antes incluso del bypass: si el usuario escribio
+        // algo en denyPatterns es que no lo quiere ver nunca, no "salvo que hoy
+        // tenga prisa". Quien llame a esto deberia usar deniedBy y cortar del todo;
+        // devolver true aqui es la red por si alguien solo mira este metodo.
+        if (this.deniedBy(toolName, args))
+            return true;
         if (this.mode === "bypass")
             return false;
         if (this.mode === "plan")
@@ -192,6 +443,21 @@ export class PermissionManager {
         if (toolName === "delete_file") {
             return !this.isPatternAllowed(toolName, args);
         }
+        // Mover o copiar encima de algo que ya existe borra el destino, exactamente
+        // igual que un delete_file, y hasta ahora caia en la rama de abajo y pasaba
+        // sin dialogo. La herramienta se niega a pisar nada sin overwrite, asi que
+        // este flag es la declaracion de intenciones de destruir el destino y se
+        // trata como el borrado que es. Se mira el argumento y no el disco: esta
+        // tabla decide con lo que pide el modelo, no con lo que haya en el sistema
+        // de ficheros en ese instante.
+        if (toolName === "move_copy_file" && args?.overwrite === true) {
+            return !this.isPatternAllowed(toolName, args);
+        }
+        // create_image que no sea SVG se pregunta como un comando: lo que corre es
+        // el texto que ha escrito el modelo, y ni el usuario ni /undo lo ven venir.
+        if (isCodeGeneration(toolName, args)) {
+            return !this.isPatternAllowed(toolName, args);
+        }
         // Comandos de terminal: solo preguntar si son destructivos o peligrosos
         if (toolName === "run_command") {
             const command = typeof args?.command === "string" ? args.command : "";
@@ -200,12 +466,85 @@ export class PermissionManager {
             }
             return false;
         }
+        // Escribir FUERA del proyecto no es una edicion, es tocar la maquina.
+        //
+        // El comentario de abajo lleva desde siempre diciendo "en el proyecto", pero
+        // nadie comprobaba la ruta: ni aqui ni en writeFile/editFile/moveCopyFile,
+        // que hacen path.resolve y siguen adelante (writeFile hasta crea los
+        // directorios que falten). Asi que write_file sobre C:\Windows\... o
+        // move_copy_file hacia ../../otro-proyecto salian sin un solo dialogo,
+        // mientras que el MISMO cambio hecho con run_command si lo pedia
+        // (isDangerousCommand, punto 4). La misma accion, bloqueada por un camino y
+        // abierta por el otro.
+        //
+        // Y /undo no es red aqui: vive solo en memoria de la sesion.
+        const fuera = this.rutasFueraDelProyecto(toolName, args, cwd);
+        if (fuera.length > 0) {
+            return !this.isPatternAllowed(toolName, args);
+        }
         // Ediciones y escrituras en el proyecto: fluidas (el usuario puede usar /undo)
         if (this.mode === "acceptEdits" || this.mode === "default") {
             return false;
         }
         return false;
     }
+    /**
+     * Rutas de la llamada que caen fuera de la raiz del proyecto. Vacio si todo
+     * queda dentro (o si la herramienta no escribe en disco: leer fuera del
+     * proyecto es legitimo y no se pregunta).
+     */
+    rutasFueraDelProyecto(toolName, args, cwd) {
+        const campos = RUTAS_DE_ESCRITURA[toolName];
+        if (!campos)
+            return [];
+        const raiz = cwd ? path.resolve(cwd) : this.projectRoot;
+        // create_image con SVG tambien escribe donde le digan; la rama de Python ya
+        // se pregunta antes por ser ejecucion de codigo.
+        return campos
+            .map((campo) => args?.[campo])
+            .filter((ruta) => isOutsideProject(raiz, ruta))
+            .map((ruta) => String(ruta));
+    }
+    /**
+     * Patron denegado: devuelve cual, o null. Corta la llamada entera; no es un
+     * "pregunta antes".
+     *
+     * denyPatterns se leia del settings.json y se volvia a guardar tal cual, pero
+     * NADIE lo consultaba: la unica lista que se miraba era la de allow. Es decir,
+     * prohibir algo por configuracion no hacia absolutamente nada.
+     *
+     * La coincidencia es la misma que la del allow (firma exacta o prefijo de
+     * comando) con una diferencia deliberada: un allow no puede autorizar lo que
+     * venga encadenado detras, pero un deny si tiene que alcanzarlo. Si no,
+     * "echo hola && git push --force" se saltaria un deny de "git push" con solo
+     * poner algo inocente delante.
+     */
+    deniedBy(toolName, args) {
+        if (this.denyPatterns.size === 0)
+            return null;
+        const command = typeof args?.command === "string" ? args.command.trim() : "";
+        const detail = String(args?.path ?? args?.outputPath ?? args?.action ?? "");
+        const trozos = command ? sentencias(command) : [];
+        for (const pattern of this.denyPatterns) {
+            const p = pattern.trim();
+            if (!p)
+                continue;
+            // Denegar una herramienta entera ("delete_file", "chrome") es una peticion
+            // razonable. Al reves, autorizarla entera, no lo es: por eso el allow no
+            // acepta esta forma.
+            if (p === toolName)
+                return pattern;
+            if (this.coincideExacta(p, toolName, command, detail))
+                return pattern;
+            if (this.coincidePrefijo(p, toolName, command))
+                return pattern;
+            for (const trozo of trozos) {
+                if (this.coincidePrefijo(p, toolName, trozo))
+                    return pattern;
+            }
+        }
+        return null;
+    }
     /**
      * Un patron autorizado vale para ESE comando, no para cualquiera que lo
      * contenga. Con la comparacion por subcadena de antes, autorizar "git status"
@@ -214,26 +553,43 @@ export class PermissionManager {
      */
     isPatternAllowed(toolName, args) {
         const command = typeof args?.command === "string" ? args.command.trim() : "";
-        const detail = String(args?.path ?? args?.action ?? "");
+        const detail = String(args?.path ?? args?.outputPath ?? args?.action ?? "");
+        // Si la linea trae mas de una sentencia, ningun prefijo la autoriza: lo que
+        // va detras del separador no lo ha aprobado nadie. Solo vale entonces la
+        // firma exacta, que es el comando completo escrito a mano.
+        const encadenado = ENCADENADO.test(command);
+        // Segunda barrera, independiente de con que patron se guardo: lo
+        // irreversible se pregunta siempre. Los patrones demasiado anchos que ya
+        // estan escritos en el settings.json de mucha gente ("git", "rm") quedan
+        // asi desactivados sin tener que ir a buscarlos uno a uno.
+        if (command && isDangerousCommand(command))
+            return false;
         for (const pattern of this.allowPatterns) {
             const p = pattern.trim();
             if (!p)
                 continue;
-            // Firma exacta de la llamada: "run_command:npm test".
-            if (p === `${toolName}:${command || detail}`)
+            if (this.coincideExacta(p, toolName, command, detail))
                 return true;
-            // Un prefijo de comando ("npm", "git status") autoriza sus variantes, pero
-            // solo al principio de la linea y sin otro comando encadenado detras.
-            if (command && toolName === "run_command") {
-                const bare = p.startsWith("run_command:") ? p.slice("run_command:".length) : p;
-                if (bare && (command === bare || command.startsWith(`${bare} `)) && !/[;&|]/.test(command)) {
-                    return true;
-                }
-            }
-            // Rutas y acciones: coincidencia exacta.
-            if (detail && (p === detail || p === `${toolName}:${detail}`))
+            if (!encadenado && this.coincidePrefijo(p, toolName, command))
                 return true;
         }
         return false;
     }
+    /** Firma exacta de la llamada ("run_command:npm test") o ruta/accion exacta. */
+    coincideExacta(p, toolName, command, detail) {
+        if (p === `${toolName}:${command || detail}`)
+            return true;
+        if (detail && (p === detail || p === `${toolName}:${detail}`))
+            return true;
+        return false;
+    }
+    /** Prefijo de comando ("npm", "git status"), solo al principio de la linea. */
+    coincidePrefijo(p, toolName, command) {
+        if (!command || toolName !== "run_command")
+            return false;
+        const bare = p.startsWith("run_command:") ? p.slice("run_command:".length) : p;
+        if (!bare)
+            return false;
+        return command === bare || command.startsWith(`${bare} `);
+    }
 }

package/dist/config/quota.js

@@ -63,21 +63,44 @@ function load() {
         return [];
     }
 }
+/**
+ * Guarda el libro de gasto de forma atomica.
+ *
+ * Antes se escribia directamente sobre usage.json. Si el proceso moria a mitad
+ * -Ctrl+C, un cierre de sesion de Windows, la bateria- el archivo quedaba
+ * truncado, load() no podia parsearlo y devolvia la lista vacia: el contador de
+ * cuota se ponia a cero y el usuario empezaba el mes de nuevo a costa nuestra.
+ *
+ * Escribir en un temporal y renombrar lo evita: el renombrado es atomico en el
+ * mismo sistema de archivos, asi que usage.json o es el de antes o es el nuevo,
+ * nunca la mitad de uno.
+ */
 function save(entries) {
     try {
         const dir = path.dirname(USAGE_FILE);
         if (!fs.existsSync(dir))
             fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(USAGE_FILE, JSON.stringify(entries), "utf-8");
+        const temporal = `${USAGE_FILE}.${process.pid}.tmp`;
+        fs.writeFileSync(temporal, JSON.stringify(entries), "utf-8");
+        fs.renameSync(temporal, USAGE_FILE);
     }
     catch {
         // Si no se puede escribir, se sigue trabajando. Perder la cuenta es malo;
         // dejar al usuario tirado por no poder escribir un archivo es peor.
+        try {
+            fs.unlinkSync(`${USAGE_FILE}.${process.pid}.tmp`);
+        }
+        catch { }
     }
 }
 export function recordUsage(costUsd, ahora = Date.now()) {
     if (!Number.isFinite(costUsd) || costUsd <= 0)
         return;
+    // Se relee justo antes de escribir, no al principio del turno: con dos
+    // sesiones abiertas, la que guardaba segunda pisaba el apunte de la primera y
+    // ese gasto desaparecia del libro. Releer aqui no elimina la carrera -harian
+    // falta cerrojos entre procesos- pero reduce la ventana a los microsegundos
+    // entre esta lectura y el renombrado.
     const entries = load();
     entries.push({ t: ahora, c: costUsd });
     save(entries);

package/dist/config/updater.d.ts

@@ -0,0 +1,68 @@
+/** Cada cuanto se le pregunta al registro. Doce veces al dia no aporta nada. */
+export declare const HORAS_ENTRE_COMPROBACIONES = 6;
+export interface CacheDeActualizacion {
+    /** Milisegundos epoch de la ultima vez que se pregunto. */
+    comprobadoEn?: number;
+    /** Ultima version que dijo el registro. */
+    ultima?: string;
+    /** Version que ya se instalo sola, para no volver a anunciarla. */
+    avisadaDe?: string;
+}
+/**
+ * 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 declare function esMasNueva(candidata: string, actual: string): boolean;
+/**
+ * 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 declare function esInstalacionDeDesarrollo(raizDelPaquete: string): boolean;
+export declare function leerCache(fichero?: string): CacheDeActualizacion;
+export declare function guardarCache(datos: CacheDeActualizacion, fichero?: string): void;
+/** Si toca preguntar al registro. Un reloj adelantado no deja de comprobar nunca. */
+export declare function tocaComprobar(cache: CacheDeActualizacion, ahora: number): boolean;
+/** Le pregunta al registro. Devuelve null si no contesta a tiempo o no se entiende. */
+export declare function ultimaVersionPublicada(url?: string): Promise<string | null>;
+export interface ResultadoDeInstalacion {
+    ok: boolean;
+    /** Que decirle al usuario. Vacio significa que no hay nada que decir. */
+    mensaje: string;
+}
+/**
+ * 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 declare function instalar(version: string, ejecutar?: typeof spawnNpm): Promise<ResultadoDeInstalacion>;
+declare function spawnNpm(args: string[]): Promise<{
+    codigo: number;
+    salida: string;
+}>;
+export interface Ajustes {
+    versionActual: string;
+    raizDelPaquete: string;
+    ahora: number;
+    /** Fuerza la comprobacion aunque no toque, para el comando /actualizar. */
+    forzar?: boolean;
+    automatico?: boolean;
+}
+/**
+ * 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 declare function comprobarActualizacion(ajustes: Ajustes): Promise<string>;
+export {};