chocolatito-code 1.0.0 → 1.2.0

package/dist/config/license.js

@@ -47,13 +47,25 @@ function readRc() {
         return {};
     }
 }
+/**
+ * Devuelve null si se guardo, o el motivo del fallo si no.
+ *
+ * Antes se tragaba la excepcion entera. Con el perfil del usuario en un recurso
+ * de solo lectura, el archivo sin permisos o el disco lleno, activar decia
+ * "Licencia activada" y no guardaba nada: el arranque siguiente volvia a pedir
+ * la clave y consumia otra de las 3 activaciones del cliente, hasta bloquearle
+ * una licencia que era suya.
+ */
 function writeRc(patch) {
     try {
         const p = getGlobalConfigPath();
         const actual = readRc();
         fs.writeFileSync(p, JSON.stringify({ ...actual, ...patch }, null, 2), "utf-8");
+        return null;
+    }
+    catch (err) {
+        return err?.code || err?.message || String(err);
     }
-    catch { }
 }
 export function getStoredLicense() {
     return readRc().license || null;
@@ -63,6 +75,30 @@ function nombreDeMaquina() {
     const host = os.hostname() || "equipo";
     return `${host} (${os.platform()})`;
 }
+/**
+ * Codigos que significan "no he podido preguntar", no "te digo que no".
+ *
+ * 429 es el limite de peticiones documentado de Lemon Squeezy: basta con que
+ * dos equipos del mismo cliente arranquen a la vez. 408, 409, 425 y todo 5xx
+ * son caidas o reintentos. Ninguno opina sobre la licencia de nadie.
+ */
+function esCaidaTemporal(status) {
+    return status === 408 || status === 409 || status === 425 || status === 429 || status >= 500;
+}
+/**
+ * Solo la API de licencias contesta con estos campos.
+ *
+ * Un {"error":"Not Found"} de un cambio de ruta, o el {"message":"Server
+ * Error"} de un 500, son JSON perfectamente validos y parsean igual de bien,
+ * pero no son un veredicto sobre ninguna clave.
+ */
+function esRespuestaDeLicencia(data) {
+    if (!data || typeof data !== "object")
+        return false;
+    return (typeof data.activated === "boolean" ||
+        typeof data.valid === "boolean" ||
+        typeof data.deactivated === "boolean");
+}
 async function post(endpoint, params) {
     const res = await fetch(`${API}/${endpoint}`, {
         method: "POST",
@@ -73,8 +109,33 @@ async function post(endpoint, params) {
         body: new URLSearchParams(params).toString(),
         signal: AbortSignal.timeout(15_000),
     });
-    // 400 y 404 traen cuerpo JSON con el motivo; no son fallos de red.
-    return await res.json();
+    // Aqui estaba la mitad que faltaba del punto 2 de arriba: se hacia res.json()
+    // sin mirar NUNCA el codigo. Solo contaba como "no he podido preguntar" que
+    // fetch lanzase. Una respuesta de error CON cuerpo JSON —el 429 del limite de
+    // peticiones, un 500 de una caida, un 404 por cambio de ruta— llegaba abajo
+    // como valid/activated ausentes, o sea como "la licencia no vale", y echaba
+    // al cliente que habia pagado sin darle el margen de 7 dias.
+    if (esCaidaTemporal(res.status)) {
+        throw new Error(res.status === 429
+            ? "Lemon Squeezy esta limitando las peticiones (HTTP 429)"
+            : `Lemon Squeezy no responde bien (HTTP ${res.status})`);
+    }
+    let data;
+    try {
+        data = await res.json();
+    }
+    catch {
+        // Pasa con las paginas HTML que mete un balanceador delante de la API.
+        throw new Error(`Respuesta ilegible de Lemon Squeezy (HTTP ${res.status})`);
+    }
+    // 400 y 404 SI traen el motivo en el cuerpo cuando hablan de la clave, y esos
+    // se dejan pasar para que traducir() los explique: siempre vienen con su
+    // activated/valid/deactivated. Un 4xx que no trae ninguno de los tres no esta
+    // hablando de la licencia, asi que tampoco puede condenarla.
+    if (res.status >= 400 && !esRespuestaDeLicencia(data)) {
+        throw new Error(`Lemon Squeezy respondio HTTP ${res.status} sin decir nada de la clave`);
+    }
+    return data;
 }
 /** La clave tiene que ser de NUESTRA tienda, no de una cualquiera. */
 function esDeNuestraTienda(data) {
@@ -112,11 +173,28 @@ export async function activate(licenseKey) {
     // Chocolatito y el cliente no necesita clave de DeepSeek. Sin escribir esto,
     // el CLI seguiria apuntando a api.deepseek.com y pidiendole al suscriptor una
     // clave que no tiene por que tener.
-    const yaConfigurado = readRc();
-    const parche = { license };
-    if (yaConfigurado.managed !== false)
-        parche.managed = true;
-    writeRc(parche);
+    //
+    // Se escribe SIEMPRE. Antes se respetaba un managed:false previo, y el unico
+    // sitio de todo el producto que escribe managed:false es deactivate(): quien
+    // liberaba el equipo y volvia a activar la misma clave aqui mismo se quedaba
+    // fuera del modo suscripcion, con el CLI pidiendole una clave de DeepSeek que
+    // no tiene o, peor, gastando la suya si la tenia guardada de antes.
+    const fallo = writeRc({ license, managed: true });
+    if (fallo) {
+        // La activacion ya esta consumida en Lemon Squeezy y no hay donde guardarla,
+        // asi que el arranque siguiente pediria la clave otra vez: tres vueltas y el
+        // cliente se queda bloqueado con una clave suya. Se devuelve la activacion
+        // antes de contarlo, para que reintentar no cueste nada.
+        try {
+            await post("deactivate", { license_key: license.key, instance_id: license.instanceId });
+        }
+        catch { }
+        return {
+            kind: "unpersisted",
+            reason: `Tu licencia es valida, pero no se pudo guardar en ${getGlobalConfigPath()} (${fallo}). ` +
+                "Arregla los permisos de ese archivo y vuelve a intentarlo.",
+        };
+    }
     return { kind: "ok", license };
 }
 export async function validate(license) {
@@ -142,6 +220,9 @@ export async function validate(license) {
         customerEmail: data?.meta?.customer_email || license.customerEmail,
         productName: data?.meta?.product_name || license.productName,
     };
+    // Si aqui no se puede escribir no se corta nada: la licencia ya esta en el
+    // archivo, solo se queda sin refrescar la fecha y se volvera a preguntar en el
+    // arranque siguiente. No cuesta activaciones, al contrario que en activate().
     writeRc({ license: actualizada });
     return { kind: "ok", license: actualizada };
 }
@@ -158,7 +239,18 @@ export async function deactivate() {
         if (!data?.deactivated) {
             return { ok: false, message: traducir(data?.error) };
         }
-        writeRc({ license: undefined, managed: false });
+        const fallo = writeRc({ license: undefined, managed: false });
+        if (fallo) {
+            // Lemon Squeezy ya ha borrado la instancia. Si encima decimos que todo fue
+            // bien, la licencia se queda escrita en el archivo y el arranque siguiente
+            // valida una activacion que ya no existe: "esta maquina ya no figura como
+            // activada" sin que el usuario haya hecho nada raro.
+            return {
+                ok: false,
+                message: `Se libero el equipo en Lemon Squeezy, pero no se pudo actualizar ${getGlobalConfigPath()} (${fallo}): ` +
+                    "la licencia sigue escrita ahi. Borra ese archivo a mano o el proximo arranque fallara al comprobarla.",
+            };
+        }
         return {
             ok: true,
             message: "Licencia liberada en este equipo. Ya puedes activarla en otro.",
@@ -256,6 +348,12 @@ export async function ensureLicense() {
             console.log(chalk.red(`\n✖ ${res.reason}\n`));
             return false;
         }
+        if (res.kind === "unpersisted") {
+            // Decir "✔ Licencia activada" aqui era mentira con consecuencias: sin
+            // guardar nada, cada arranque volvia a activar y se comia una activacion.
+            console.log(chalk.red(`\n✖ ${res.reason}\n`));
+            return false;
+        }
         console.log(chalk.red(`\n✖ No se pudo contactar con Lemon Squeezy para activar (${res.reason}).`) +
             chalk.gray("\n  Comprueba tu conexión e inténtalo otra vez.\n"));
         return false;

package/dist/config/limits.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Presupuestos de ejecucion.
+ *
+ * Estaban escritos en el codigo: 30 iteraciones en el bucle principal y 14 en
+ * los subagentes. Son numeros razonables para la tarea media y equivocados en
+ * los dos extremos: en una refactorizacion grande el turno se corta a medias
+ * ("se agoto el limite de 30 iteraciones") y hay que repetir la peticion para
+ * que siga; en un guion desatendido, 30 vueltas de un agente perdido son 30
+ * llamadas pagadas antes de que nadie mire.
+ *
+ * Quien conoce su tarea y su presupuesto es el usuario, asi que se saca a
+ * configuracion. Con topes: un limite de 500 iteraciones no es una eleccion
+ * informada, es un cero de mas.
+ */
+export interface Limites {
+    /** Vueltas del bucle principal en un turno. */
+    iteracionesPorTurno: number;
+    /** Vueltas de un subagente. */
+    iteracionesDeSubagente: number;
+}
+export declare const LIMITES_POR_DEFECTO: Limites;
+/**
+ * Lee los limites de la configuracion. El proyecto puede bajarlos o subirlos:
+ * a diferencia de los permisos, aqui no hay nada que elevar —un limite mas
+ * alto no da acceso a nada, solo gasta mas cuota del propio usuario, y el corte
+ * duro sigue siendo el tope de 200.
+ */
+export declare function leerLimites(cwd?: string): Limites;

package/dist/config/limits.js

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const LIMITES_POR_DEFECTO = {
+    iteracionesPorTurno: 30,
+    iteracionesDeSubagente: 14,
+};
+const MINIMO = 3;
+const MAXIMO = 200;
+function enRango(valor, porDefecto) {
+    const n = typeof valor === "string" ? Number(valor) : valor;
+    if (typeof n !== "number" || !Number.isFinite(n))
+        return porDefecto;
+    return Math.max(MINIMO, Math.min(MAXIMO, Math.round(n)));
+}
+/**
+ * Lee los limites de la configuracion. El proyecto puede bajarlos o subirlos:
+ * a diferencia de los permisos, aqui no hay nada que elevar —un limite mas
+ * alto no da acceso a nada, solo gasta mas cuota del propio usuario, y el corte
+ * duro sigue siendo el tope de 200.
+ */
+export function leerLimites(cwd = process.cwd()) {
+    const limites = { ...LIMITES_POR_DEFECTO };
+    for (const ruta of [
+        path.join(os.homedir(), ".chocolatito", "settings.json"),
+        path.join(cwd, ".chocolatito", "settings.json"),
+    ]) {
+        try {
+            if (!fs.existsSync(ruta))
+                continue;
+            const parsed = JSON.parse(fs.readFileSync(ruta, "utf-8"));
+            const l = parsed?.limits;
+            if (!l)
+                continue;
+            if (l.maxIterations !== undefined) {
+                limites.iteracionesPorTurno = enRango(l.maxIterations, limites.iteracionesPorTurno);
+            }
+            if (l.subagentIterations !== undefined) {
+                limites.iteracionesDeSubagente = enRango(l.subagentIterations, limites.iteracionesDeSubagente);
+            }
+        }
+        catch { }
+    }
+    if (process.env.CHOCOLATITO_MAX_ITERATIONS) {
+        limites.iteracionesPorTurno = enRango(process.env.CHOCOLATITO_MAX_ITERATIONS, limites.iteracionesPorTurno);
+    }
+    if (process.env.CHOCOLATITO_SUBAGENT_ITERATIONS) {
+        limites.iteracionesDeSubagente = enRango(process.env.CHOCOLATITO_SUBAGENT_ITERATIONS, limites.iteracionesDeSubagente);
+    }
+    return limites;
+}

package/dist/config/nodeVersion.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Un Node viejo se dice claro, no se descubre a base de errores raros.
+ *
+ * `engines` en el package.json solo hace que npm suelte un aviso que nadie lee:
+ * la instalacion termina bien y el fallo aparece despues, al arrancar, con un
+ * "fetch is not defined" o un error de sintaxis dentro de una dependencia. El
+ * que acaba de pagar da por hecho que el producto esta roto, y no le falta
+ * razon desde donde el lo ve.
+ *
+ * Se comprueba antes que nada: antes de la licencia, antes de leer la
+ * configuracion y antes de importar nada que pueda reventar por esto mismo.
+ */
+export declare function comprobarNode(version?: string): string | null;

package/dist/config/nodeVersion.js

@@ -0,0 +1,26 @@
+/** La version de Node mas antigua con la que esto funciona. */
+const NODE_MINIMO = 20;
+/**
+ * Un Node viejo se dice claro, no se descubre a base de errores raros.
+ *
+ * `engines` en el package.json solo hace que npm suelte un aviso que nadie lee:
+ * la instalacion termina bien y el fallo aparece despues, al arrancar, con un
+ * "fetch is not defined" o un error de sintaxis dentro de una dependencia. El
+ * que acaba de pagar da por hecho que el producto esta roto, y no le falta
+ * razon desde donde el lo ve.
+ *
+ * Se comprueba antes que nada: antes de la licencia, antes de leer la
+ * configuracion y antes de importar nada que pueda reventar por esto mismo.
+ */
+export function comprobarNode(version = process.version) {
+    const mayor = Number.parseInt(String(version).replace(/^v/, "").split(".")[0], 10);
+    // Si no se entiende la version, no es motivo para no dejar trabajar a nadie.
+    if (!Number.isFinite(mayor))
+        return null;
+    if (mayor >= NODE_MINIMO)
+        return null;
+    return (`Chocolatito Code necesita Node ${NODE_MINIMO} o superior, y estas con ${version}.\n\n` +
+        `  Descargalo en https://nodejs.org (la version LTS vale).\n` +
+        `  Despues, vuelve a instalarlo:  npm i -g chocolatito-code\n\n` +
+        `No es un problema de tu licencia ni de tu conexion.`);
+}

package/dist/config/permissions.d.ts

@@ -6,18 +6,60 @@ export interface SettingsConfig {
         denyPatterns?: string[];
     };
 }
+/**
+ * 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 declare function isOutsideProject(projectRoot: string, target: unknown): boolean;
+/**
+ * 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 declare function isSvgSource(script: unknown): boolean;
 /**
  * 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.
  */
 export declare function isDangerousCommand(command: string): boolean;
+/**
+ * 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 declare function commandSignature(command: string): string;
 export declare class PermissionManager {
     mode: PermissionMode;
     allowPatterns: Set<string>;
     denyPatterns: Set<string>;
     private settingsFilePath;
+    /** Raiz del proyecto: el limite dentro del cual escribir no interrumpe. */
+    projectRoot: string;
     constructor(initialMode?: PermissionMode, cwd?: string);
     loadSettings(): void;
+    /**
+     * 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.
+     */
     private applySettings;
     saveAllowPattern(pattern: string): void;
     setMode(mode: PermissionMode): void;
@@ -27,7 +69,36 @@ export declare class PermissionManager {
      * Modo plan = SOLO LECTURA de verdad.
      */
     isBlockedInPlanMode(toolName: string, args: Record<string, any>): string | null;
-    requiresConfirmation(toolName: string, args: Record<string, any>): boolean;
+    /**
+     * `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: string, args: Record<string, any>, cwd?: string): boolean;
+    /**
+     * 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: string, args: Record<string, any>, cwd?: string): string[];
+    /**
+     * 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: string, args: Record<string, any>): string | null;
     /**
      * Un patron autorizado vale para ESE comando, no para cualquiera que lo
      * contenga. Con la comparacion por subcadena de antes, autorizar "git status"
@@ -35,4 +106,8 @@ export declare class PermissionManager {
      * apareciera en algun sitio de la linea.
      */
     private isPatternAllowed;
+    /** Firma exacta de la llamada ("run_command:npm test") o ruta/accion exacta. */
+    private coincideExacta;
+    /** Prefijo de comando ("npm", "git status"), solo al principio de la linea. */
+    private coincidePrefijo;
 }