chocolatito-code 1.0.0

package/dist/config/permissions.js

@@ -0,0 +1,239 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+/**
+ * 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.
+ */
+const OBSERVE_ONLY = {
+    computer_use: new Set([
+        "screenshot",
+        "ui_snapshot",
+        "list_windows",
+        "find_element",
+        "get_active_window",
+        "cursor_position",
+        "wait",
+        "sleep",
+    ]),
+    chrome: new Set(["status", "tabs", "snapshot", "get_text", "screenshot", "wait_for", "notice"]),
+    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"]),
+};
+/** Herramientas que conducen el ordenador o el navegador del usuario. */
+const CONTROL_TOOLS = Object.keys(OBSERVE_ONLY);
+/** Herramientas que modifican el disco o el repositorio. */
+const MODIFYING_TOOLS = ["edit_file", "write_file", "delete_file", "move_copy_file", "git_commit"];
+/** 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 ?? ""));
+}
+/** Conduce de verdad el ordenador o el navegador: clics, teclado, navegacion, JS. */
+function isActuation(toolName, args) {
+    return CONTROL_TOOLS.includes(toolName) && !isObserveOnly(toolName, args);
+}
+/**
+ * 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 function isDangerousCommand(command) {
+    if (!command || typeof command !== "string")
+        return false;
+    const cmd = command.trim();
+    // 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) ||
+        /\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)) {
+        return true;
+    }
+    // 3. Terminación de procesos y apagado del sistema
+    if (/\b(taskkill|kill\s+-9|pkill\s+-9|shutdown|reboot|stop-computer|restart-computer)\b/i.test(cmd) ||
+        /\bStop-Process\b[^\n]*-Force/i.test(cmd)) {
+        return true;
+    }
+    // 4. Modificación de directorios críticos del sistema operativo
+    if (/(c:\\windows|c:\\program files|\/etc\/|\/usr\/bin\/|\/bin\/)/i.test(cmd) &&
+        /\b(copy|move|del|rm|write|out-file|>)\b/i.test(cmd)) {
+        return true;
+    }
+    // 5. Descargar y ejecutar de un tirón. Lo que corre luego no lo ha visto
+    //    nadie: ni el modelo ni el usuario. Es el único caso de esta lista donde
+    //    el comando parece inofensivo y el contenido es el peligro.
+    if (/\b(curl|wget|iwr|Invoke-WebRequest)\b[^\n]*\|\s*(ba|z|k)?sh\b/i.test(cmd) ||
+        /\b(curl|iwr|Invoke-WebRequest|Invoke-RestMethod)\b[^\n]*\|\s*(iex|Invoke-Expression)\b/i.test(cmd) ||
+        /\b(iex|Invoke-Expression)\s*\(/i.test(cmd)) {
+        return true;
+    }
+    // 6. Acciones hacia fuera: salen de la máquina y no se pueden deshacer.
+    //    Publicar una versión equivocada se arregla con otra versión, nunca
+    //    borrando la anterior.
+    if (/\b(npm|yarn|pnpm)\s+publish\b/i.test(cmd) ||
+        /\bdocker\s+push\b/i.test(cmd) ||
+        /\bgh\s+(release\s+create|repo\s+delete)\b/i.test(cmd)) {
+        return true;
+    }
+    // 7. Permisos abiertos de par en par sobre un árbol entero.
+    if (/\bchmod\s+-R\s+777\b/i.test(cmd)) {
+        return true;
+    }
+    return false;
+}
+export class PermissionManager {
+    mode = "default";
+    allowPatterns = new Set();
+    denyPatterns = new Set();
+    settingsFilePath;
+    constructor(initialMode = "default", cwd = process.cwd()) {
+        this.mode = initialMode;
+        this.settingsFilePath = path.join(cwd, ".chocolatito", "settings.json");
+        this.loadSettings();
+    }
+    loadSettings() {
+        // 1. Global settings ~/.chocolatito/settings.json
+        const globalPath = path.join(os.homedir(), ".chocolatito", "settings.json");
+        if (fs.existsSync(globalPath)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(globalPath, "utf-8"));
+                this.applySettings(parsed);
+            }
+            catch { }
+        }
+        // 2. Local project settings .chocolatito/settings.json
+        if (fs.existsSync(this.settingsFilePath)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(this.settingsFilePath, "utf-8"));
+                this.applySettings(parsed);
+            }
+            catch { }
+        }
+    }
+    applySettings(settings) {
+        if (settings.permissions?.mode) {
+            this.mode = settings.permissions.mode;
+        }
+        if (settings.permissions?.allowPatterns) {
+            settings.permissions.allowPatterns.forEach((p) => this.allowPatterns.add(p));
+        }
+        if (settings.permissions?.denyPatterns) {
+            settings.permissions.denyPatterns.forEach((p) => this.denyPatterns.add(p));
+        }
+    }
+    saveAllowPattern(pattern) {
+        this.allowPatterns.add(pattern);
+        const dir = path.dirname(this.settingsFilePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+        const config = {
+            permissions: {
+                mode: this.mode,
+                allowPatterns: Array.from(this.allowPatterns),
+                denyPatterns: Array.from(this.denyPatterns),
+            },
+        };
+        fs.writeFileSync(this.settingsFilePath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    getMode() {
+        return this.mode;
+    }
+    isReadOnly() {
+        return this.mode === "plan";
+    }
+    /**
+     * Modo plan = SOLO LECTURA de verdad.
+     */
+    isBlockedInPlanMode(toolName, args) {
+        if (this.mode !== "plan")
+            return null;
+        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") {
+            return "El modo plan es de solo lectura: no se ejecutan comandos. Investiga con view_file, grep_search y list_dir.";
+        }
+        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.");
+        }
+        return null;
+    }
+    requiresConfirmation(toolName, args) {
+        if (this.mode === "bypass")
+            return false;
+        if (this.mode === "plan")
+            return false;
+        // Mirar es gratis en cualquier modo
+        if (isObserveOnly(toolName, args))
+            return false;
+        // Conducir el ordenador o el navegador real del usuario siempre se pregunta
+        if (isActuation(toolName, args)) {
+            return !this.isPatternAllowed(toolName, args);
+        }
+        // Borrado directo de archivos: siempre se pregunta
+        if (toolName === "delete_file") {
+            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 : "";
+            if (isDangerousCommand(command)) {
+                return !this.isPatternAllowed(toolName, args);
+            }
+            return false;
+        }
+        // Ediciones y escrituras en el proyecto: fluidas (el usuario puede usar /undo)
+        if (this.mode === "acceptEdits" || this.mode === "default") {
+            return false;
+        }
+        return false;
+    }
+    /**
+     * Un patron autorizado vale para ESE comando, no para cualquiera que lo
+     * contenga. Con la comparacion por subcadena de antes, autorizar "git status"
+     * dejaba pasar tambien "rm -rf . && git status": bastaba con que el patron
+     * apareciera en algun sitio de la linea.
+     */
+    isPatternAllowed(toolName, args) {
+        const command = typeof args?.command === "string" ? args.command.trim() : "";
+        const detail = String(args?.path ?? args?.action ?? "");
+        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}`)
+                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}`))
+                return true;
+        }
+        return false;
+    }
+}

package/dist/config/quota.d.ts

@@ -0,0 +1,58 @@
+/**
+ * CUOTA DE USO
+ *
+ * Dos ventanas deslizantes a la vez, igual que hacen las herramientas del ramo:
+ *
+ *  - Una de 5 horas, que impide que una sola sesion intensa se coma la semana.
+ *  - Una de 7 dias, que es el limite de verdad.
+ *
+ * Deslizantes, no de calendario: la de 5 horas mira las ultimas 5 horas desde
+ * AHORA, no un bloque fijo de reloj. Con bloques fijos, quien empieza a las
+ * 4:59 se queda sin nada en un minuto, y eso se percibe como una averia.
+ *
+ * IMPORTANTE — ESTO ES EL CONTADOR, NO LA BARRERA.
+ *
+ * Corre en la maquina del cliente, en JavaScript legible. Quien quiera saltarselo
+ * solo tiene que abrir dist/ y borrar la comprobacion. Sirve para que el usuario
+ * honesto sepa cuanto lleva gastado y no se lleve sorpresas, y para que la
+ * cuenta este hecha y probada. La barrera de verdad tiene que vivir en el
+ * servidor que guarda la clave maestra: es el unico sitio donde el cliente no
+ * puede tocar. Mientras el usuario ponga su propia clave de API, aqui no se
+ * limita nada, porque el dinero que gasta es suyo.
+ */
+export interface QuotaConfig {
+    /** Presupuesto mensual de API por usuario, en USD. */
+    monthlyBudgetUsd: number;
+    /** Tamano de la ventana corta, en horas. */
+    windowHours: number;
+    /** Tope de la ventana corta, en USD. */
+    windowBudgetUsd: number;
+    /** Tope de los ultimos 7 dias, en USD. */
+    weeklyBudgetUsd: number;
+}
+export declare function getQuotaConfig(): QuotaConfig;
+/**
+ * Modo gestionado: la API la paga Chocolatito, no el usuario.
+ *
+ * Solo entonces tiene sentido limitar. Si el usuario trae su propia clave, el
+ * gasto es suyo y ponerle un tope seria impertinente.
+ */
+export declare function isManagedMode(): boolean;
+export declare function recordUsage(costUsd: number, ahora?: number): void;
+export interface QuotaStatus {
+    allowed: boolean;
+    /** Motivo legible cuando no se permite. */
+    reason?: string;
+    /** Cuando vuelve a haber margen. */
+    resetAt?: Date;
+    spentWindowUsd: number;
+    spentWeekUsd: number;
+    config: QuotaConfig;
+}
+export declare function checkQuota(ahora?: number): QuotaStatus;
+/** Cuanto falta para la hora indicada, en lenguaje llano. */
+export declare function faltaPara(fecha: Date, ahora?: number): string;
+/** Mensaje completo para cuando se agota la cuota. */
+export declare function mensajeDeCorte(status: QuotaStatus): string;
+/** Resumen corto para el pie de cada turno. Vacio si no hay nada que decir. */
+export declare function quotaBadge(status: QuotaStatus): string;

package/dist/config/quota.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const DEFAULT_MONTHLY_USD = 5;
+const WINDOW_HOURS = 5;
+/** La ventana corta es un freno de golpe, no un reparto a partes iguales:
+ *  se deja gastar hasta un 40% de la semana en una sola sesion intensa. */
+const WINDOW_SHARE_OF_WEEK = 0.4;
+function num(name, fallback) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const v = Number(raw);
+    return Number.isFinite(v) && v > 0 ? v : fallback;
+}
+export function getQuotaConfig() {
+    const monthly = num("CHOCOLATITO_MONTHLY_BUDGET_USD", DEFAULT_MONTHLY_USD);
+    const weekly = num("CHOCOLATITO_WEEKLY_BUDGET_USD", (monthly * 7) / 30);
+    return {
+        monthlyBudgetUsd: monthly,
+        windowHours: num("CHOCOLATITO_WINDOW_HOURS", WINDOW_HOURS),
+        windowBudgetUsd: num("CHOCOLATITO_WINDOW_BUDGET_USD", weekly * WINDOW_SHARE_OF_WEEK),
+        weeklyBudgetUsd: weekly,
+    };
+}
+/**
+ * Modo gestionado: la API la paga Chocolatito, no el usuario.
+ *
+ * Solo entonces tiene sentido limitar. Si el usuario trae su propia clave, el
+ * gasto es suyo y ponerle un tope seria impertinente.
+ */
+export function isManagedMode() {
+    if (process.env.CHOCOLATITO_MANAGED === "1")
+        return true;
+    if (process.env.CHOCOLATITO_MANAGED === "0")
+        return false;
+    try {
+        const rc = path.join(os.homedir(), ".chocolatitorc");
+        if (!fs.existsSync(rc))
+            return false;
+        const cfg = JSON.parse(fs.readFileSync(rc, "utf-8"));
+        return cfg.managed === true;
+    }
+    catch {
+        return false;
+    }
+}
+const USAGE_FILE = path.join(os.homedir(), ".chocolatito", "usage.json");
+const RETAIN_MS = 8 * 24 * 60 * 60 * 1000;
+function load() {
+    try {
+        if (!fs.existsSync(USAGE_FILE))
+            return [];
+        const raw = JSON.parse(fs.readFileSync(USAGE_FILE, "utf-8"));
+        if (!Array.isArray(raw))
+            return [];
+        const corte = Date.now() - RETAIN_MS;
+        // Se descarta lo viejo al leer: el archivo no crece sin fin.
+        return raw.filter((e) => typeof e?.t === "number" && typeof e?.c === "number" && e.t > corte);
+    }
+    catch {
+        // Un archivo corrupto no puede dejar al usuario sin herramienta.
+        return [];
+    }
+}
+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");
+    }
+    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.
+    }
+}
+export function recordUsage(costUsd, ahora = Date.now()) {
+    if (!Number.isFinite(costUsd) || costUsd <= 0)
+        return;
+    const entries = load();
+    entries.push({ t: ahora, c: costUsd });
+    save(entries);
+}
+function gastadoDesde(entries, desde) {
+    return entries.reduce((suma, e) => (e.t >= desde ? suma + e.c : suma), 0);
+}
+/** Cuando caduca el gasto mas antiguo que aun cuenta en la ventana. */
+function seLiberaEn(entries, desde, ventanaMs) {
+    const dentro = entries.filter((e) => e.t >= desde).sort((a, b) => a.t - b.t);
+    if (dentro.length === 0)
+        return null;
+    return new Date(dentro[0].t + ventanaMs);
+}
+export function checkQuota(ahora = Date.now()) {
+    const config = getQuotaConfig();
+    const entries = load();
+    const ventanaMs = config.windowHours * 60 * 60 * 1000;
+    const semanaMs = 7 * 24 * 60 * 60 * 1000;
+    const spentWindowUsd = gastadoDesde(entries, ahora - ventanaMs);
+    const spentWeekUsd = gastadoDesde(entries, ahora - semanaMs);
+    if (!isManagedMode()) {
+        // Clave propia del usuario: se lleva la cuenta para informar, no se frena.
+        return { allowed: true, spentWindowUsd, spentWeekUsd, config };
+    }
+    if (spentWeekUsd >= config.weeklyBudgetUsd) {
+        return {
+            allowed: false,
+            reason: "Has agotado tu cuota semanal de uso.",
+            resetAt: seLiberaEn(entries, ahora - semanaMs, semanaMs) || undefined,
+            spentWindowUsd,
+            spentWeekUsd,
+            config,
+        };
+    }
+    if (spentWindowUsd >= config.windowBudgetUsd) {
+        return {
+            allowed: false,
+            reason: `Has agotado tu cuota de las ultimas ${config.windowHours} horas.`,
+            resetAt: seLiberaEn(entries, ahora - ventanaMs, ventanaMs) || undefined,
+            spentWindowUsd,
+            spentWeekUsd,
+            config,
+        };
+    }
+    return { allowed: true, spentWindowUsd, spentWeekUsd, config };
+}
+/** Cuanto falta para la hora indicada, en lenguaje llano. */
+export function faltaPara(fecha, ahora = Date.now()) {
+    const ms = fecha.getTime() - ahora;
+    if (ms <= 0)
+        return "ya";
+    const minutos = Math.ceil(ms / 60000);
+    if (minutos < 60)
+        return `${minutos} min`;
+    const horas = Math.floor(minutos / 60);
+    const resto = minutos % 60;
+    if (horas < 24)
+        return resto > 0 ? `${horas} h ${resto} min` : `${horas} h`;
+    const dias = Math.floor(horas / 24);
+    return `${dias} d ${horas % 24} h`;
+}
+/** Mensaje completo para cuando se agota la cuota. */
+export function mensajeDeCorte(status) {
+    const cuando = status.resetAt
+        ? ` Vuelves a tener margen en ${faltaPara(status.resetAt)} (${status.resetAt.toLocaleTimeString("es-ES", { hour: "2-digit", minute: "2-digit" })}).`
+        : "";
+    return `${status.reason}${cuando}`;
+}
+/** Resumen corto para el pie de cada turno. Vacio si no hay nada que decir. */
+export function quotaBadge(status) {
+    if (!isManagedMode())
+        return "";
+    const pct = Math.min(100, Math.round((status.spentWeekUsd / status.config.weeklyBudgetUsd) * 100));
+    return `${pct}% de la cuota semanal`;
+}

package/dist/hooks/manager.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Hooks: puntos de enganche para que el usuario imponga sus propias reglas.
+ *
+ * La version anterior solo miraba si existia un script llamado como el evento y
+ * se quedaba con lo que imprimiera. No podia BLOQUEAR nada, que es justo lo que
+ * hace util un hook: impedir un `rm -rf`, exigir que se formatee tras editar, o
+ * inyectar contexto antes de que el modelo responda.
+ *
+ * Se sigue el modelo de Claude Code: configuracion en settings.json con
+ * matchers, el evento entra por stdin como JSON, y el hook contesta por stdout
+ * con un JSON que puede permitir, denegar o pedir confirmacion.
+ */
+export type HookEvent = "SessionStart" | "SessionEnd" | "UserPromptSubmit" | "PreToolUse" | "PostToolUse" | "Stop";
+export interface HookDefinition {
+    type?: "command";
+    command: string;
+    timeout?: number;
+    shell?: "bash" | "powershell";
+}
+export interface HookMatcher {
+    /** Nombre de herramienta, lista separada por "|", o expresion regular. */
+    matcher?: string;
+    hooks: HookDefinition[];
+}
+export type HooksConfig = Partial<Record<HookEvent, HookMatcher[]>>;
+export interface HookDecision {
+    /** "deny" corta la accion; "allow" se la salta el permiso; "ask" pregunta. */
+    permissionDecision?: "allow" | "deny" | "ask";
+    permissionDecisionReason?: string;
+    /** Texto que se anade al contexto del modelo. */
+    additionalContext?: string;
+    /** Reemplaza los argumentos de la herramienta antes de ejecutarla. */
+    updatedInput?: Record<string, any>;
+    /** Mensaje informativo para el usuario. */
+    systemMessage?: string;
+}
+export declare class HookManager {
+    private config;
+    private disabled;
+    private cwd;
+    constructor(cwd?: string);
+    /** settings.json del usuario y del proyecto; el proyecto tiene prioridad. */
+    private load;
+    get hasHooks(): boolean;
+    describe(): string;
+    /**
+     * El matcher sigue las reglas de Claude Code: vacio o "*" vale para todo, un
+     * texto simple (o lista con "|") compara exacto, y cualquier otra cosa se
+     * trata como expresion regular.
+     */
+    private matches;
+    private hooksFor;
+    /**
+     * Ejecuta los hooks del evento y devuelve la decision combinada.
+     * Gana el veto: si CUALQUIER hook deniega, se deniega.
+     */
+    run(event: HookEvent, payload: Record<string, any>, matchValue?: string): Promise<HookDecision>;
+    /** Compatibilidad con la API anterior. */
+    triggerHook(event: HookEvent, context: Record<string, any>): Promise<string | null>;
+}