chocolatito-code 1.0.0

package/dist/config/engine.js

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import OpenAI from "openai";
+import { getEngineBaseUrl } from "./constants.js";
+import { getStoredLicense } from "./license.js";
+import { isManagedMode } from "./quota.js";
+let versionCache = null;
+/** Version del paquete instalado, para versionar el contrato con el proxy. */
+export function clientVersion() {
+    if (versionCache)
+        return versionCache;
+    try {
+        const aqui = path.dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(fs.readFileSync(path.resolve(aqui, "..", "..", "package.json"), "utf-8"));
+        versionCache = String(pkg.version || "0.0.0");
+    }
+    catch {
+        versionCache = "0.0.0";
+    }
+    return versionCache;
+}
+/**
+ * La credencial que se manda en el Bearer.
+ *
+ * En suscripcion es la clave de licencia: el cliente no tiene clave de DeepSeek
+ * y no debe tenerla, porque la maestra vive en el proxy. Con clave propia se
+ * manda la del usuario, como siempre.
+ */
+export function engineCredential(fallbackApiKey) {
+    if (isManagedMode()) {
+        const license = getStoredLicense();
+        if (license?.key)
+            return license.key;
+    }
+    return fallbackApiKey;
+}
+/**
+ * Cabeceras propias en cada peticion.
+ *
+ * Van en TODAS las rutas para que el proxy pueda atribuir el gasto, rechazar
+ * clientes de version incompatible y distinguir a Chocolatito Code de un SDK
+ * cualquiera apuntando al mismo endpoint.
+ */
+export function engineHeaders(route) {
+    const cabeceras = {
+        "X-Chocolatito-Client": `chocolatito-code/${clientVersion()}`,
+        "X-Chocolatito-Route": route,
+    };
+    const license = getStoredLicense();
+    // Identifica la ACTIVACION, no al cliente: permite al proxy cortar un equipo
+    // concreto sin tocar la licencia entera.
+    if (license?.instanceId)
+        cabeceras["X-Chocolatito-Instance"] = license.instanceId;
+    return cabeceras;
+}
+/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+export function createEngineClient(apiKey, route) {
+    return new OpenAI({
+        apiKey: engineCredential(apiKey),
+        baseURL: getEngineBaseUrl(),
+        defaultHeaders: engineHeaders(route),
+    });
+}
+/**
+ * Traduce un error del motor a algo que el usuario entienda.
+ *
+ * Sin esto, el proxy diciendo "se te acabo la cuota" (402) llega a pantalla como
+ * "Error en el motor tras varios reintentos: 402 ...", que ademas miente: un 402
+ * no se reintenta nunca.
+ */
+export function explicarErrorDelMotor(err) {
+    const status = err?.status ?? err?.response?.status;
+    const mensaje = String(err?.error?.message || err?.message || "");
+    if (status === 402) {
+        return mensaje || "Has agotado la cuota de uso incluida en tu suscripción.";
+    }
+    if (status === 401 || status === 403) {
+        if (isManagedMode()) {
+            return ("Tu licencia no es válida para el motor. Comprueba tu suscripción con /licencia, " +
+                "o vuelve a activarla si la renovaste hace poco.");
+        }
+        return "La clave de API no es válida. Revísala en ~/.chocolatitorc.";
+    }
+    return null;
+}

package/dist/config/env.d.ts

@@ -0,0 +1,13 @@
+export declare function getGlobalConfigPath(): string;
+export declare function loadSavedApiKey(): string | null;
+/**
+ * Guarda la clave SIN borrar el resto del archivo.
+ *
+ * Antes escribia el fichero entero con solo {apiKey, updatedAt}, asi que
+ * guardar una clave se llevaba por delante la licencia y el modo gestionado.
+ * Para un suscriptor eso es fatal y silencioso: introduce una clave, pierde su
+ * licencia activada y el CLI deja de apuntar al proxy sin decir nada.
+ */
+export declare function saveApiKey(apiKey: string): void;
+export declare function promptForApiKey(): Promise<string>;
+export declare function ensureApiKey(): Promise<string>;

package/dist/config/env.js

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import dotenv from "dotenv";
+import readline from "node:readline";
+import chalk from "chalk";
+import { CONFIG_FILE_NAME } from "./constants.js";
+dotenv.config();
+export function getGlobalConfigPath() {
+    return path.join(os.homedir(), CONFIG_FILE_NAME);
+}
+export function loadSavedApiKey() {
+    // 1. Environment variables
+    if (process.env.CHOCOLATITO_API_KEY?.trim())
+        return process.env.CHOCOLATITO_API_KEY.trim();
+    if (process.env.DEEPSEEK_API_KEY?.trim())
+        return process.env.DEEPSEEK_API_KEY.trim();
+    if (process.env.OPENAI_API_KEY?.trim())
+        return process.env.OPENAI_API_KEY.trim();
+    // 2. Local project .env
+    const localEnv = path.join(process.cwd(), ".env");
+    if (fs.existsSync(localEnv)) {
+        try {
+            const parsed = dotenv.parse(fs.readFileSync(localEnv, "utf-8"));
+            if (parsed.CHOCOLATITO_API_KEY?.trim())
+                return parsed.CHOCOLATITO_API_KEY.trim();
+            if (parsed.DEEPSEEK_API_KEY?.trim())
+                return parsed.DEEPSEEK_API_KEY.trim();
+        }
+        catch { }
+    }
+    // 3. Global config ~/.chocolatitorc
+    const globalPath = getGlobalConfigPath();
+    if (fs.existsSync(globalPath)) {
+        try {
+            const content = JSON.parse(fs.readFileSync(globalPath, "utf-8"));
+            if (content.apiKey && typeof content.apiKey === "string" && content.apiKey.trim().length > 5) {
+                return content.apiKey.trim();
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+/**
+ * Guarda la clave SIN borrar el resto del archivo.
+ *
+ * Antes escribia el fichero entero con solo {apiKey, updatedAt}, asi que
+ * guardar una clave se llevaba por delante la licencia y el modo gestionado.
+ * Para un suscriptor eso es fatal y silencioso: introduce una clave, pierde su
+ * licencia activada y el CLI deja de apuntar al proxy sin decir nada.
+ */
+export function saveApiKey(apiKey) {
+    const globalPath = getGlobalConfigPath();
+    let actual = {};
+    try {
+        if (fs.existsSync(globalPath))
+            actual = JSON.parse(fs.readFileSync(globalPath, "utf-8"));
+    }
+    catch {
+        // Un archivo corrupto se reemplaza; no hay nada que conservar.
+    }
+    const config = {
+        ...actual,
+        apiKey: apiKey.trim(),
+        updatedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(globalPath, JSON.stringify(config, null, 2), "utf-8");
+}
+export async function promptForApiKey() {
+    if (!process.stdin.isTTY) {
+        console.error(chalk.red("\nError: No se encontró ninguna API Key configurada y no hay terminal interactiva.\n" +
+            "Configura la variable de entorno CHOCOLATITO_API_KEY o DEEPSEEK_API_KEY en tu entorno.\n"));
+        process.exit(1);
+    }
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log(chalk.bold.hex("#D97757")("\n🔑 CONFIGURACIÓN DE ACCESO — CHOCOLATITO CODE"));
+        console.log(chalk.gray("Ingresa tu API Key (se guardará de forma segura en ~/.chocolatitorc):"));
+        rl.question(chalk.hex("#A855F7")("API Key ❯ "), (key) => {
+            rl.close();
+            const cleaned = key.trim();
+            if (cleaned.length > 5) {
+                saveApiKey(cleaned);
+                console.log(chalk.green("✔ API Key guardada exitosamente.\n"));
+                resolve(cleaned);
+            }
+            else {
+                console.log(chalk.red("Error: Clave no válida."));
+                process.exit(1);
+            }
+        });
+    });
+}
+export async function ensureApiKey() {
+    const existing = loadSavedApiKey();
+    if (existing)
+        return existing;
+    return await promptForApiKey();
+}

package/dist/config/license.d.ts

@@ -0,0 +1,39 @@
+export interface StoredLicense {
+    key: string;
+    instanceId: string;
+    /** ISO de la ultima confirmacion buena. */
+    lastValidated: string;
+    customerEmail?: string;
+    productName?: string;
+}
+export declare function getStoredLicense(): StoredLicense | null;
+export type LicenseOutcome = {
+    kind: "ok";
+    license: StoredLicense;
+}
+/** Lemon Squeezy respondio que no. Reembolso, cancelacion, tope de maquinas. */
+ | {
+    kind: "rejected";
+    reason: string;
+}
+/** No se pudo preguntar: red, caida del servicio, tiempo agotado. */
+ | {
+    kind: "unreachable";
+    reason: string;
+};
+export declare function activate(licenseKey: string): Promise<LicenseOutcome>;
+export declare function validate(license: StoredLicense): Promise<LicenseOutcome>;
+/** Libera esta maquina para poder usar la clave en otra. */
+export declare function deactivate(): Promise<{
+    ok: boolean;
+    message: string;
+}>;
+/**
+ * Puerta de entrada. Devuelve true si se puede seguir.
+ *
+ * Se salta entera en desarrollo con CHOCOLATITO_LICENSE_SKIP=1. No debilita
+ * nada: quien pueda poner esa variable tambien puede editar el dist/.
+ */
+export declare function ensureLicense(): Promise<boolean>;
+/** Texto del comando /licencia. */
+export declare function licenseStatus(): string;

package/dist/config/license.js

@@ -0,0 +1,306 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import chalk from "chalk";
+import { getGlobalConfigPath } from "./env.js";
+/**
+ * LICENCIAS
+ *
+ * Contra la API de licencias de Lemon Squeezy, que tiene una propiedad muy util:
+ * las llamadas se autentican con la clave del propio cliente, sin cabecera de
+ * autorizacion. No hace falta servidor, ni base de datos, ni meter ninguna clave
+ * maestra dentro del programa que se reparte.
+ *
+ * DOS FALLOS QUE HAY QUE EVITAR Y QUE NO SON OBVIOS:
+ *
+ *  1. Validar sin comprobar la TIENDA. La API responde a cualquier clave de
+ *     cualquier tienda de Lemon Squeezy. Sin comprobar el store_id, alguien
+ *     compra un producto de un euro en otra tienda cualquiera y su clave abre
+ *     Chocolatito Code.
+ *
+ *  2. Confundir "me han dicho que no" con "no he podido preguntar". Si un fallo
+ *     de red se trata como licencia invalida, una caida de una hora de Lemon
+ *     Squeezy deja tirados a todos los clientes a la vez. Una respuesta negativa
+ *     corta al instante; no poder preguntar da margen.
+ *
+ * Y lo que esto NO es: corre en la maquina del cliente, en JavaScript legible.
+ * Frena que se comparta la clave con un amigo, no a quien quiera piratearlo.
+ * La barrera de verdad solo llega cuando el motor lo pagas tu y vive detras de
+ * tu servidor.
+ */
+const API = "https://api.lemonsqueezy.com/v1/licenses";
+/** Tienda propietaria del producto. Una clave de otra tienda no vale aqui. */
+const STORE_ID = Number(process.env.CHOCOLATITO_STORE_ID || 463680);
+/** Dias que se aguanta sin poder confirmar antes de exigir conexion. */
+const GRACIA_DIAS = Number(process.env.CHOCOLATITO_LICENSE_GRACE_DAYS || 7);
+/** Horas entre comprobaciones. Por debajo de esto ni se llama. */
+const REVALIDAR_HORAS = Number(process.env.CHOCOLATITO_LICENSE_RECHECK_HOURS || 24);
+function readRc() {
+    try {
+        const p = getGlobalConfigPath();
+        if (!fs.existsSync(p))
+            return {};
+        return JSON.parse(fs.readFileSync(p, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeRc(patch) {
+    try {
+        const p = getGlobalConfigPath();
+        const actual = readRc();
+        fs.writeFileSync(p, JSON.stringify({ ...actual, ...patch }, null, 2), "utf-8");
+    }
+    catch { }
+}
+export function getStoredLicense() {
+    return readRc().license || null;
+}
+/** Nombre para reconocer esta maquina en el panel de Lemon Squeezy. */
+function nombreDeMaquina() {
+    const host = os.hostname() || "equipo";
+    return `${host} (${os.platform()})`;
+}
+async function post(endpoint, params) {
+    const res = await fetch(`${API}/${endpoint}`, {
+        method: "POST",
+        headers: {
+            Accept: "application/json",
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        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();
+}
+/** La clave tiene que ser de NUESTRA tienda, no de una cualquiera. */
+function esDeNuestraTienda(data) {
+    const store = data?.meta?.store_id;
+    return typeof store === "number" && store === STORE_ID;
+}
+export async function activate(licenseKey) {
+    let data;
+    try {
+        data = await post("activate", {
+            license_key: licenseKey.trim(),
+            instance_name: nombreDeMaquina(),
+        });
+    }
+    catch (err) {
+        return { kind: "unreachable", reason: err?.message || String(err) };
+    }
+    if (!data?.activated) {
+        return { kind: "rejected", reason: traducir(data?.error) };
+    }
+    if (!esDeNuestraTienda(data)) {
+        return {
+            kind: "rejected",
+            reason: "Esa clave es de otra tienda, no de Chocolatito Code.",
+        };
+    }
+    const license = {
+        key: licenseKey.trim(),
+        instanceId: data.instance.id,
+        lastValidated: new Date().toISOString(),
+        customerEmail: data?.meta?.customer_email,
+        productName: data?.meta?.product_name,
+    };
+    // Activar una licencia ES entrar en modo suscripcion: el motor lo paga
+    // 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);
+    return { kind: "ok", license };
+}
+export async function validate(license) {
+    let data;
+    try {
+        data = await post("validate", {
+            license_key: license.key,
+            instance_id: license.instanceId,
+        });
+    }
+    catch (err) {
+        return { kind: "unreachable", reason: err?.message || String(err) };
+    }
+    if (!data?.valid) {
+        return { kind: "rejected", reason: traducir(data?.error) };
+    }
+    if (!esDeNuestraTienda(data)) {
+        return { kind: "rejected", reason: "Esa clave es de otra tienda, no de Chocolatito Code." };
+    }
+    const actualizada = {
+        ...license,
+        lastValidated: new Date().toISOString(),
+        customerEmail: data?.meta?.customer_email || license.customerEmail,
+        productName: data?.meta?.product_name || license.productName,
+    };
+    writeRc({ license: actualizada });
+    return { kind: "ok", license: actualizada };
+}
+/** Libera esta maquina para poder usar la clave en otra. */
+export async function deactivate() {
+    const license = getStoredLicense();
+    if (!license)
+        return { ok: false, message: "No hay ninguna licencia guardada en este equipo." };
+    try {
+        const data = await post("deactivate", {
+            license_key: license.key,
+            instance_id: license.instanceId,
+        });
+        if (!data?.deactivated) {
+            return { ok: false, message: traducir(data?.error) };
+        }
+        writeRc({ license: undefined, managed: false });
+        return {
+            ok: true,
+            message: "Licencia liberada en este equipo. Ya puedes activarla en otro.",
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            message: `No se pudo contactar con Lemon Squeezy: ${err?.message || String(err)}`,
+        };
+    }
+}
+const MENSAJES = [
+    [/activation limit/i, "Esta clave ya se esta usando en el maximo de equipos permitido. Libera uno con /licencia liberar."],
+    [/license key has been disabled|disabled/i, "Esta licencia esta desactivada. Si crees que es un error, escribe al soporte."],
+    [/expired/i, "Esta licencia ha caducado."],
+    [/not found|invalid/i, "Esa clave no existe. Revisa que la hayas copiado entera."],
+    [/instance/i, "Esta maquina ya no figura como activada. Vuelve a introducir tu clave."],
+];
+function traducir(error) {
+    const texto = String(error || "La licencia no es valida.");
+    for (const [patron, mensaje] of MENSAJES) {
+        if (patron.test(texto))
+            return mensaje;
+    }
+    return texto;
+}
+/**
+ * True cuando se ejecuta desde el codigo fuente, no desde el paquete instalado.
+ *
+ * Sin esto, el propio autor se queda fuera de su herramienta en cuanto se activa
+ * la licencia: trabaja sobre el repo y no tiene clave que meter.
+ *
+ * Se distingue por el tsconfig.json, que existe en el repo y NO se publica (el
+ * campo "files" del package.json solo incluye dist, extension y los textos). Un
+ * cliente nunca lo tiene, asi que esto no abre ninguna puerta en el producto.
+ */
+function enDesarrollo() {
+    try {
+        const aqui = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1"));
+        const raiz = path.resolve(aqui, "..", "..");
+        return fs.existsSync(path.join(raiz, "tsconfig.json")) && fs.existsSync(path.join(raiz, "src"));
+    }
+    catch {
+        return false;
+    }
+}
+function horasDesde(iso) {
+    const t = Date.parse(iso);
+    if (!Number.isFinite(t))
+        return Infinity;
+    return (Date.now() - t) / 3_600_000;
+}
+async function pedirClave() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        console.log(chalk.bold.hex("#D97757")("\n🔑 ACTIVACIÓN — CHOCOLATITO CODE"));
+        console.log(chalk.gray("Pega la clave de licencia que recibiste por correo al comprar."));
+        rl.question(chalk.hex("#A855F7")("Licencia ❯ "), (respuesta) => {
+            rl.close();
+            resolve(respuesta.trim());
+        });
+    });
+}
+/**
+ * Puerta de entrada. Devuelve true si se puede seguir.
+ *
+ * Se salta entera en desarrollo con CHOCOLATITO_LICENSE_SKIP=1. No debilita
+ * nada: quien pueda poner esa variable tambien puede editar el dist/.
+ */
+export async function ensureLicense() {
+    if (process.env.CHOCOLATITO_LICENSE_SKIP === "1")
+        return true;
+    if (enDesarrollo())
+        return true;
+    let license = getStoredLicense();
+    // Primera vez: se pide la clave y se activa esta maquina.
+    if (!license) {
+        if (!process.stdin.isTTY) {
+            console.log(chalk.red("\n✖ No hay licencia activada en este equipo") +
+                chalk.gray("\n  Ejecuta 'chocolatito' en una terminal para introducirla.\n"));
+            return false;
+        }
+        const clave = await pedirClave();
+        if (!clave) {
+            console.log(chalk.red("\n✖ No se introdujo ninguna clave.\n"));
+            return false;
+        }
+        const res = await activate(clave);
+        if (res.kind === "ok") {
+            console.log(chalk.green(`\n✔ Licencia activada${res.license.customerEmail ? ` para ${res.license.customerEmail}` : ""}.\n`));
+            return true;
+        }
+        if (res.kind === "rejected") {
+            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;
+    }
+    // Ya activada: solo se vuelve a preguntar de vez en cuando.
+    if (horasDesde(license.lastValidated) < REVALIDAR_HORAS)
+        return true;
+    const res = await validate(license);
+    if (res.kind === "ok")
+        return true;
+    if (res.kind === "rejected") {
+        // Respuesta clara de Lemon Squeezy: se corta ya.
+        console.log(chalk.red(`\n✖ ${res.reason}\n`));
+        return false;
+    }
+    // No se pudo preguntar. Aqui es donde importa no castigar al cliente por una
+    // caida que no es suya.
+    const dias = horasDesde(license.lastValidated) / 24;
+    if (dias <= GRACIA_DIAS) {
+        const quedan = Math.max(0, Math.ceil(GRACIA_DIAS - dias));
+        console.log(chalk.yellow(`⚠ No se pudo comprobar la licencia (${res.reason}).`) +
+            chalk.gray(` Sigues trabajando; quedan ${quedan} día(s) de margen.\n`));
+        return true;
+    }
+    console.log(chalk.red(`\n✖ Llevas más de ${GRACIA_DIAS} días sin poder comprobar la licencia.`) +
+        chalk.gray("\n  Conéctate a internet una vez para reanudarla.\n"));
+    return false;
+}
+/** Texto del comando /licencia. */
+export function licenseStatus() {
+    const l = getStoredLicense();
+    if (!l)
+        return chalk.yellow("No hay ninguna licencia activada en este equipo.");
+    const horas = horasDesde(l.lastValidated);
+    const cuando = horas < 1 ? "hace menos de una hora" : `hace ${Math.floor(horas)} h`;
+    return [
+        chalk.bold.hex("#D97757")("Licencia de Chocolatito Code"),
+        `  Producto:    ${l.productName || "Chocolatito Code"}`,
+        l.customerEmail ? `  A nombre de: ${l.customerEmail}` : "",
+        `  Clave:       ${l.key.slice(0, 8)}…${l.key.slice(-4)}`,
+        `  Equipo:      ${nombreDeMaquina()}`,
+        `  Comprobada:  ${cuando}`,
+        "",
+        chalk.gray("  /licencia liberar  — suelta este equipo para usar la clave en otro"),
+    ]
+        .filter(Boolean)
+        .join("\n");
+}

package/dist/config/permissions.d.ts

@@ -0,0 +1,38 @@
+export type PermissionMode = "default" | "acceptEdits" | "plan" | "bypass";
+export interface SettingsConfig {
+    permissions?: {
+        mode?: PermissionMode;
+        allowPatterns?: string[];
+        denyPatterns?: string[];
+    };
+}
+/**
+ * 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;
+export declare class PermissionManager {
+    mode: PermissionMode;
+    allowPatterns: Set<string>;
+    denyPatterns: Set<string>;
+    private settingsFilePath;
+    constructor(initialMode?: PermissionMode, cwd?: string);
+    loadSettings(): void;
+    private applySettings;
+    saveAllowPattern(pattern: string): void;
+    setMode(mode: PermissionMode): void;
+    getMode(): PermissionMode;
+    isReadOnly(): boolean;
+    /**
+     * Modo plan = SOLO LECTURA de verdad.
+     */
+    isBlockedInPlanMode(toolName: string, args: Record<string, any>): string | null;
+    requiresConfirmation(toolName: string, args: Record<string, any>): boolean;
+    /**
+     * 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.
+     */
+    private isPatternAllowed;
+}