chocolatito-code 1.6.6 → 1.6.8

package/dist/agent/context.d.ts

@@ -9,4 +9,10 @@ export interface ProjectContext {
     repoMap: string;
 }
 export declare function olvidarMapa(cwd?: string): void;
+interface ModularRule {
+    relPath: string;
+    content: string;
+}
+export declare function scanModularRules(baseDir: string, currentDir?: string, depth?: number): ModularRule[];
 export declare function getProjectContext(cwd?: string): Promise<ProjectContext>;
+export {};

package/dist/agent/context.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import { execa } from "execa";
 import { RULES_FILE_NAME } from "../config/constants.js";
 import { construirMapa } from "./repoMap.js";
+import { nombreDelSistema } from "../config/plataforma.js";
 /** Tokens que puede ocupar el mapa dentro del prompt de sistema. */
 const PRESUPUESTO_MAPA = 4_000;
 /**
@@ -36,11 +37,52 @@ function mapaDe(cwd) {
     cacheDeMapas.set(clave, mapa);
     return mapa;
 }
+const IGNORED_RULE_DIRS = new Set(["node_modules", ".git", "dist", "tests", "assets"]);
+const RULE_FILE_NAMES = [".chocolatitorules", ".cursorrules"];
+export function scanModularRules(baseDir, currentDir = baseDir, depth = 0) {
+    if (depth > 3)
+        return [];
+    const rules = [];
+    try {
+        const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        // En subdirectorios (depth >= 1), buscar archivos de reglas modulares
+        if (depth >= 1) {
+            for (const ruleFileName of RULE_FILE_NAMES) {
+                const match = entries.find((e) => e.isFile() && e.name === ruleFileName);
+                if (match) {
+                    const fullPath = path.join(currentDir, match.name);
+                    try {
+                        const content = fs.readFileSync(fullPath, "utf-8").trim();
+                        if (content) {
+                            const relPath = path.relative(baseDir, fullPath).replace(/\\/g, "/");
+                            rules.push({ relPath, content });
+                        }
+                    }
+                    catch { }
+                }
+            }
+        }
+        // Recorrer subdirectorios recursivamente hasta profundidad 3
+        if (depth < 3) {
+            const subdirs = entries
+                .filter((e) => e.isDirectory() && !IGNORED_RULE_DIRS.has(e.name.toLowerCase()))
+                .sort((a, b) => a.name.localeCompare(b.name));
+            for (const subdir of subdirs) {
+                const nextDir = path.join(currentDir, subdir.name);
+                rules.push(...scanModularRules(baseDir, nextDir, depth + 1));
+            }
+        }
+    }
+    catch { }
+    return rules;
+}
 export async function getProjectContext(cwd = process.cwd()) {
     let rulesContent = null;
-    // 1. Look for CHOCOLATITO.md or CLAUDE.md
+    // 1. Reglas principales de raíz: CHOCOLATITO.md, CLAUDE.md, .chocolatitorules o .cursorrules
     const rulesPath = path.join(cwd, RULES_FILE_NAME);
     const fallbackClaudePath = path.join(cwd, "CLAUDE.md");
+    const rootChocolatitoRules = path.join(cwd, ".chocolatitorules");
+    const rootCursorRules = path.join(cwd, ".cursorrules");
     if (fs.existsSync(rulesPath)) {
         try {
             rulesContent = fs.readFileSync(rulesPath, "utf-8");
@@ -53,6 +95,31 @@ export async function getProjectContext(cwd = process.cwd()) {
         }
         catch { }
     }
+    else if (fs.existsSync(rootChocolatitoRules)) {
+        try {
+            rulesContent = fs.readFileSync(rootChocolatitoRules, "utf-8");
+        }
+        catch { }
+    }
+    else if (fs.existsSync(rootCursorRules)) {
+        try {
+            rulesContent = fs.readFileSync(rootCursorRules, "utf-8");
+        }
+        catch { }
+    }
+    // Reglas modulares en subdirectorios (.chocolatitorules y .cursorrules hasta profundidad 3)
+    const modularRules = scanModularRules(cwd);
+    if (modularRules.length > 0) {
+        const modularText = modularRules
+            .map((r) => `[${r.relPath}]:\n${r.content}`)
+            .join("\n\n");
+        if (rulesContent && rulesContent.trim()) {
+            rulesContent = `${rulesContent.trim()}\n\n${modularText}`;
+        }
+        else {
+            rulesContent = modularText;
+        }
+    }
     // 2. Git branch & status detection
     let gitBranch = null;
     try {
@@ -145,7 +212,7 @@ export async function getProjectContext(cwd = process.cwd()) {
     else if (fs.existsSync(cmakePath)) {
         projectType = "C / C++ (CMake)";
     }
-    const osName = process.platform === "win32" ? "Windows" : process.platform === "darwin" ? "macOS" : "Linux";
+    const osName = nombreDelSistema();
     return {
         cwd,
         os: osName,

package/dist/agent/loop.js

@@ -1167,6 +1167,12 @@ export class AgentLoop {
             const firma = commandSignature(command);
             if (firma)
                 this.permissions.saveAllowPattern(`${fnName}:${firma}`);
+            else
+                this.permissions.saveAllowPattern(`${fnName}:${command}`);
+            return;
+        }
+        if (fnName === "computer_use" || fnName === "chrome" || fnName === "browser" || fnName === "browser_live") {
+            this.permissions.saveAllowPattern(fnName);
             return;
         }
         this.permissions.saveAllowPattern(fnArgs?.path || fnName);
@@ -1191,5 +1197,7 @@ function getToolSummary(name, args) {
         return args.dirPath;
     if (args.action)
         return args.action + (args.url ? ` (${args.url})` : "");
+    if (args.taskId)
+        return args.taskId;
     return "";
 }

package/dist/agent/toolGate.js

@@ -1,6 +1,6 @@
 import process from "node:process";
 import chalk from "chalk";
-import { PermissionManager, commandSignature } from "../config/permissions.js";
+import { PermissionManager, commandSignature, isDangerousCommand } from "../config/permissions.js";
 import { HookManager } from "../hooks/manager.js";
 import { askToolPermission } from "../ui/permissionPrompt.js";
 import { releaseKeyboard, retomarTeclado } from "../ui/interrupt.js";
@@ -89,12 +89,18 @@ export async function autorizarHerramienta(toolName, args, cwd = process.cwd(),
             };
         }
         if (res.rememberPattern) {
-            // La firma (binario mas subcomando), NO el primer token: guardar "git" al
-            // aprobar un "git status" autoriza por prefijo todo lo que empiece igual.
-            const patron = finales.command
-                ? `${toolName}:${commandSignature(String(finales.command))}`
-                : finales.path || toolName;
-            permissions.saveAllowPattern(String(patron));
+            if (finales.command) {
+                if (!isDangerousCommand(String(finales.command))) {
+                    const firma = commandSignature(String(finales.command));
+                    permissions.saveAllowPattern(`${toolName}:${firma || finales.command}`);
+                }
+            }
+            else if (toolName === "computer_use" || toolName === "chrome" || toolName === "browser" || toolName === "browser_live") {
+                permissions.saveAllowPattern(toolName);
+            }
+            else {
+                permissions.saveAllowPattern(String(finales.path || toolName));
+            }
         }
     }
     return { permitida: true, args: finales };

package/dist/agent/verifier.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { execa } from "execa";
+import { shellPosix } from "../config/plataforma.js";
 /**
  * Verificacion automatica despues de editar: se corre el linter o el
  * comprobador de tipos del proyecto y, si falla, el error vuelve al modelo en
@@ -112,7 +113,7 @@ function elVerificadorNoSePudoEjecutar(codigo, salida) {
     return /command not found|is not recognized as the name of a cmdlet|CommandNotFoundException|no such file or directory|ENOENT/i.test(salida);
 }
 export async function verificar(comando, cwd) {
-    const shell = process.platform === "win32" ? "powershell.exe" : "/bin/sh";
+    const shell = process.platform === "win32" ? "powershell.exe" : shellPosix("sh");
     const args = process.platform === "win32" ? ["-NoProfile", "-Command", comando] : ["-c", comando];
     try {
         const res = await execa(shell, args, {

package/dist/config/permissions.d.ts

@@ -6,6 +6,19 @@ export interface SettingsConfig {
         denyPatterns?: string[];
     };
 }
+/**
+ * Acciones de SOLO OBSERVAR de cada herramienta de control.
+ *
+ * La tabla anterior estaba del reves: preguntaba por 'ui_snapshot' (que solo lee
+ * la pantalla) y dejaba pasar sin preguntar la herramienta 'chrome' entera, que
+ * conduce el navegador REAL del usuario con sus sesiones ya iniciadas. En la
+ * practica eso empujaba al usuario a poner el modo bypass para dejar de
+ * contestar dialogos inutiles, y con el bypass puesto ya no quedaba ninguna
+ * barrera justo donde hacia falta.
+ *
+ * La regla ahora es una sola: mirar es gratis, actuar se pregunta.
+ */
+export declare const OBSERVE_ONLY: Record<string, Set<string>>;
 /**
  * Una ruta esta fuera del proyecto si, resuelta, no cuelga de la raiz.
  *
@@ -29,6 +42,10 @@ export declare function isSvgSource(script: unknown): boolean;
  * Comandos seguros de desarrollo (python, npm, pytest, tsc, git status, etc.) no interrumpen al usuario.
  */
 export declare function isDangerousCommand(command: string): boolean;
+/**
+ * Detecta operaciones destructivas de Git que nunca deben guardarse automáticamente.
+ */
+export declare function isGitDestructive(command: string): boolean;
 /**
  * Firma con la que se recuerda un comando aprobado.
  *

package/dist/config/permissions.js

@@ -14,7 +14,7 @@ import { isBrowserAttached } from "../tools/browserSession.js";
  *
  * La regla ahora es una sola: mirar es gratis, actuar se pregunta.
  */
-const OBSERVE_ONLY = {
+export const OBSERVE_ONLY = {
     computer_use: new Set([
         "screenshot",
         "ui_snapshot",
@@ -25,7 +25,17 @@ const OBSERVE_ONLY = {
         "wait",
         "sleep",
     ]),
-    chrome: new Set(["status", "tabs", "snapshot", "get_text", "screenshot", "wait_for", "notice"]),
+    chrome: new Set([
+        "status",
+        "tabs",
+        "snapshot",
+        "get_text",
+        "screenshot",
+        "wait_for",
+        "notice",
+        "console_logs",
+        "network_errors",
+    ]),
     browser: new Set(["attach", "tabs", "snapshot", "get_text", "screenshot", "wait_for", "console"]),
     browser_live: new Set(["attach", "tabs", "snapshot", "get_text", "screenshot", "wait_for", "console"]),
 };
@@ -208,6 +218,14 @@ export function isDangerousCommand(command) {
     }
     return false;
 }
+/**
+ * Detecta operaciones destructivas de Git que nunca deben guardarse automáticamente.
+ */
+export function isGitDestructive(command) {
+    if (!command || typeof command !== "string")
+        return false;
+    return GIT_DESTRUCTIVO.some((re) => re.test(command.trim()));
+}
 /**
  * Cuanto restringe cada modo. Sirve para decidir si una capa de settings sube o
  * baja el liston: el proyecto solo puede subirlo.
@@ -389,7 +407,7 @@ export class PermissionManager {
         if (MODIFYING_TOOLS.includes(toolName)) {
             return `El modo plan es de solo lectura: "${toolName}" no puede modificar archivos ni el repositorio.`;
         }
-        if (toolName === "run_command") {
+        if (toolName === "run_command" || toolName === "start_background_task") {
             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
@@ -459,7 +477,7 @@ export class PermissionManager {
             return !this.isPatternAllowed(toolName, args);
         }
         // Comandos de terminal: solo preguntar si son destructivos o peligrosos
-        if (toolName === "run_command") {
+        if (toolName === "run_command" || toolName === "start_background_task") {
             const command = typeof args?.command === "string" ? args.command : "";
             if (isDangerousCommand(command)) {
                 return !this.isPatternAllowed(toolName, args);
@@ -568,8 +586,15 @@ export class PermissionManager {
             const p = pattern.trim();
             if (!p)
                 continue;
-            if (this.coincideExacta(p, toolName, command, detail))
+            // Autorizar la herramienta completa (p. ej. "computer_use", "chrome", "browser", "delete_file")
+            // o con comodin ("computer_use:*"). Esto es vital para computer_use y actuadores donde cada clic
+            // no debe volver a interrumpir tras haber seleccionado "no preguntar mas".
+            if ((p === toolName || p === `${toolName}:*`) && toolName !== "run_command" && toolName !== "start_background_task")
+                return true;
+            // Firma o coincidencia exacta de llamada, comando, firma o ruta
+            if (!encadenado && this.coincideExacta(p, toolName, command, detail))
                 return true;
+            // Coincidencia de prefijo para comandos
             if (!encadenado && this.coincidePrefijo(p, toolName, command))
                 return true;
         }
@@ -579,15 +604,30 @@ export class PermissionManager {
     coincideExacta(p, toolName, command, detail) {
         if (p === `${toolName}:${command || detail}`)
             return true;
+        if ((toolName === "run_command" || toolName === "start_background_task") && command) {
+            if (p === `run_command:${command}` || p === `start_background_task:${command}`)
+                return true;
+        }
         if (detail && (p === detail || p === `${toolName}:${detail}`))
             return true;
+        // Normalizacion de rutas para Windows (\ vs /)
+        if (detail) {
+            const dNorm = detail.replace(/\\/g, "/");
+            const pNorm = p.replace(/\\/g, "/");
+            if (pNorm === dNorm || pNorm === `${toolName}:${dNorm}`)
+                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")
+        if (!command || (toolName !== "run_command" && toolName !== "start_background_task"))
             return false;
-        const bare = p.startsWith("run_command:") ? p.slice("run_command:".length) : p;
+        let bare = p;
+        if (bare.startsWith("run_command:"))
+            bare = bare.slice("run_command:".length);
+        else if (bare.startsWith("start_background_task:"))
+            bare = bare.slice("start_background_task:".length);
         if (!bare)
             return false;
         return command === bare || command.startsWith(`${bare} `);

package/dist/config/plataforma.d.ts

@@ -0,0 +1,62 @@
+/**
+ * PLATAFORMAS
+ *
+ * Termux (Android) es Unix para todo menos para lo unico que importa aqui: no
+ * existe /bin. Bash y sh viven bajo el prefijo de Termux, asi que un
+ * "/bin/bash" fijo no significa "en Android funciona peor": significa que falla
+ * TODA herramienta que lance un comando, que es casi todo lo que hace el
+ * agente. Y el error que sale es un ENOENT del propio shell, que no se parece
+ * en nada a la causa.
+ *
+ * TRES COSAS QUE NO SON OBVIAS:
+ *
+ *  1. Node en Termux reporta process.platform === "android", no "linux". Por eso
+ *     el campo "os" de package.json tiene que nombrarlo: si no, npm corta la
+ *     instalacion con EBADPLATFORM antes de bajar un solo byte, y el usuario ni
+ *     llega a ver el programa.
+ *
+ *  2. El prefijo no se puede dar por fijo. Sale de $PREFIX, que Termux exporta
+ *     siempre, porque la app tambien se instala con otro id de paquete
+ *     (com.termux.dev, forks de F-Droid) y ahi la ruta cambia. La constante es
+ *     el ultimo recurso, no la primera opcion.
+ *
+ *  3. Hay un termux-exec que reescribe /bin/sh al vuelo y en muchos moviles esto
+ *     "ya funcionaba" por el. Pero viene segun version e instalacion, asi que
+ *     depender de el es que el producto funcione o no segun de donde bajo el
+ *     usuario su Termux. Se resuelve la ruta y se acaba la loteria.
+ */
+export declare const esWindows: boolean;
+export declare const esAndroid: boolean;
+/** Solo por si $PREFIX no esta: la ruta de la instalacion normal de Termux. */
+export declare const PREFIJO_TERMUX = "/data/data/com.termux/files/usr";
+type Existe = (ruta: string) => boolean;
+export declare function prefijoTermux(env?: NodeJS.ProcessEnv, existe?: Existe): string;
+/**
+ * Los shells de este sistema, en el orden en que hay que probarlos.
+ *
+ * `preferencia` decide el orden, no el resultado: quien quiere bash lo quiere
+ * por comodidad (tuberias, $(), &&), y quien pide sh es porque le basta. Los dos
+ * aceptan al otro antes que quedarse sin poder ejecutar nada.
+ */
+export declare function candidatosDeShell(preferencia?: "bash" | "sh", prefijo?: string): string[];
+/**
+ * Separado de shellPosix() para poder probar Android sin un Android: recibe la
+ * plataforma, el prefijo y quien sabe si un archivo existe.
+ */
+export declare function resolverShell(opciones: {
+    plataforma: string;
+    preferencia?: "bash" | "sh";
+    prefijo?: string;
+    existe: Existe;
+}): string;
+/** El shell con el que ejecutar una linea de comandos en un sistema Unix. */
+export declare function shellPosix(preferencia?: "bash" | "sh"): string;
+/** Candidatos de bash de este sistema, en orden. Para los hooks. */
+export declare function candidatosDeBash(): string[];
+/**
+ * Como se le nombra el sistema al modelo. Android se dice con Termux delante
+ * porque de "Linux" el modelo deduce sudo y apt-get, y ahi no hay ninguno de los
+ * dos: se instala con pkg y no hay root.
+ */
+export declare function nombreDelSistema(plataforma?: string): string;
+export {};

package/dist/config/plataforma.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * PLATAFORMAS
+ *
+ * Termux (Android) es Unix para todo menos para lo unico que importa aqui: no
+ * existe /bin. Bash y sh viven bajo el prefijo de Termux, asi que un
+ * "/bin/bash" fijo no significa "en Android funciona peor": significa que falla
+ * TODA herramienta que lance un comando, que es casi todo lo que hace el
+ * agente. Y el error que sale es un ENOENT del propio shell, que no se parece
+ * en nada a la causa.
+ *
+ * TRES COSAS QUE NO SON OBVIAS:
+ *
+ *  1. Node en Termux reporta process.platform === "android", no "linux". Por eso
+ *     el campo "os" de package.json tiene que nombrarlo: si no, npm corta la
+ *     instalacion con EBADPLATFORM antes de bajar un solo byte, y el usuario ni
+ *     llega a ver el programa.
+ *
+ *  2. El prefijo no se puede dar por fijo. Sale de $PREFIX, que Termux exporta
+ *     siempre, porque la app tambien se instala con otro id de paquete
+ *     (com.termux.dev, forks de F-Droid) y ahi la ruta cambia. La constante es
+ *     el ultimo recurso, no la primera opcion.
+ *
+ *  3. Hay un termux-exec que reescribe /bin/sh al vuelo y en muchos moviles esto
+ *     "ya funcionaba" por el. Pero viene segun version e instalacion, asi que
+ *     depender de el es que el producto funcione o no segun de donde bajo el
+ *     usuario su Termux. Se resuelve la ruta y se acaba la loteria.
+ */
+export const esWindows = process.platform === "win32";
+export const esAndroid = process.platform === "android";
+/** Solo por si $PREFIX no esta: la ruta de la instalacion normal de Termux. */
+export const PREFIJO_TERMUX = "/data/data/com.termux/files/usr";
+const existeEnDisco = (ruta) => {
+    try {
+        return fs.existsSync(ruta);
+    }
+    catch {
+        return false;
+    }
+};
+export function prefijoTermux(env = process.env, existe = existeEnDisco) {
+    const p = env["PREFIX"];
+    if (p && existe(path.posix.join(p, "bin")))
+        return p;
+    return PREFIJO_TERMUX;
+}
+/**
+ * Los shells de este sistema, en el orden en que hay que probarlos.
+ *
+ * `preferencia` decide el orden, no el resultado: quien quiere bash lo quiere
+ * por comodidad (tuberias, $(), &&), y quien pide sh es porque le basta. Los dos
+ * aceptan al otro antes que quedarse sin poder ejecutar nada.
+ */
+export function candidatosDeShell(preferencia = "bash", prefijo) {
+    const bash = [
+        prefijo ? path.posix.join(prefijo, "bin", "bash") : undefined,
+        "/bin/bash",
+        "/usr/bin/bash",
+        "/usr/local/bin/bash",
+    ];
+    const sh = [prefijo ? path.posix.join(prefijo, "bin", "sh") : undefined, "/bin/sh", "/usr/bin/sh"];
+    const orden = preferencia === "bash" ? [...bash, ...sh] : [...sh, ...bash];
+    return orden.filter((r) => !!r);
+}
+/**
+ * Separado de shellPosix() para poder probar Android sin un Android: recibe la
+ * plataforma, el prefijo y quien sabe si un archivo existe.
+ */
+export function resolverShell(opciones) {
+    const { plataforma, preferencia = "bash", existe } = opciones;
+    const enAndroid = plataforma === "android";
+    const prefijo = enAndroid ? opciones.prefijo || PREFIJO_TERMUX : undefined;
+    for (const candidato of candidatosDeShell(preferencia, prefijo)) {
+        if (existe(candidato))
+            return candidato;
+    }
+    // Ni uno. En Android se devuelve la ruta de Termux y no /bin/sh: asi el ENOENT
+    // nombra una ruta que el usuario reconoce y "pkg install bash" se ve venir.
+    const nombre = preferencia === "bash" ? "bash" : "sh";
+    return prefijo ? path.posix.join(prefijo, "bin", nombre) : `/bin/${nombre}`;
+}
+/** El shell con el que ejecutar una linea de comandos en un sistema Unix. */
+export function shellPosix(preferencia = "bash") {
+    return resolverShell({
+        plataforma: process.platform,
+        preferencia,
+        prefijo: esAndroid ? prefijoTermux() : undefined,
+        existe: existeEnDisco,
+    });
+}
+/** Candidatos de bash de este sistema, en orden. Para los hooks. */
+export function candidatosDeBash() {
+    return candidatosDeShell("bash", esAndroid ? prefijoTermux() : undefined);
+}
+/**
+ * Como se le nombra el sistema al modelo. Android se dice con Termux delante
+ * porque de "Linux" el modelo deduce sudo y apt-get, y ahi no hay ninguno de los
+ * dos: se instala con pkg y no hay root.
+ */
+export function nombreDelSistema(plataforma = process.platform) {
+    if (plataforma === "win32")
+        return "Windows";
+    if (plataforma === "darwin")
+        return "macOS";
+    if (plataforma === "android")
+        return "Android (Termux)";
+    return "Linux";
+}

package/dist/config/updater.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
+import { esAndroid, shellPosix } from "./plataforma.js";
 /**
  * Actualizaciones solas, sin que el usuario tenga que enterarse.
  *
@@ -161,7 +162,9 @@ export function instalar(version, ejecutar = spawnNpm) {
 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 });
+        // En Android hay que decir cual: shell:true significa "/bin/sh", que en
+        // Termux no existe, y la actualizacion fallaria sin explicar por que.
+        const p = spawn("npm", args, { shell: esAndroid ? shellPosix("sh") : true, windowsHide: true });
         let salida = "";
         p.stdout?.on("data", (d) => (salida += d));
         p.stderr?.on("data", (d) => (salida += d));

package/dist/hooks/manager.js

@@ -3,6 +3,7 @@ import path from "node:path";
 import os from "node:os";
 import chalk from "chalk";
 import { execa } from "execa";
+import { candidatosDeBash } from "../config/plataforma.js";
 const DEFAULT_TIMEOUT_MS = 30_000;
 /**
  * EL SHELL DE LOS HOOKS, RESUELTO A UNA RUTA QUE EXISTE
@@ -44,7 +45,7 @@ function buscarBash() {
         // /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);
+        return primeraExistente(candidatosDeBash()) ?? null;
     }
     const bases = [
         process.env["ProgramFiles"],