chocolatito-code 1.1.0 → 1.3.0

package/dist/config/engine.js

@@ -55,12 +55,33 @@ export function engineHeaders(route) {
         cabeceras["X-Chocolatito-Instance"] = license.instanceId;
     return cabeceras;
 }
-/** Cliente del motor ya configurado. Es el unico sitio donde se construye. */
+/**
+ * Cliente del motor ya configurado. Es el unico sitio donde se construye.
+ *
+ * POR QUE `maxRetries: 0`
+ *
+ * El SDK reintenta por su cuenta dos veces mas (su valor por defecto), y encima
+ * de eso el agente pasa cada llamada por `withRetry`. Dos capas apiladas, y solo
+ * una de las dos sabe algo del proxy.
+ *
+ * Medido contra un servidor de mentira: una sola llamada que recibe un 429 de
+ * "tienes 4 peticiones en curso" sale por la red TRES veces antes de que el
+ * error llegue siquiera a nuestro codigo. Y nuestro codigo lo tiene bien
+ * clasificado -`isRetryable` devuelve false para ese 429 justamente porque cada
+ * intento ocupa un hueco-, pero para entonces ya se han gastado los otros dos.
+ *
+ * Asi es como un solo corte de conexion se comia los cuatro huecos de la
+ * licencia y dejaba al usuario tres minutos sin servicio. La politica de
+ * reintentos vive en `withRetry` y en un solo sitio: ahi se sabe que un
+ * desbordamiento de contexto no puede empezar a caber, y que insistir con los
+ * huecos ocupados es la forma mas rapida de quedarse sin ninguno.
+ */
 export function createEngineClient(apiKey, route) {
     return new OpenAI({
         apiKey: engineCredential(apiKey),
         baseURL: getEngineBaseUrl(),
         defaultHeaders: engineHeaders(route),
+        maxRetries: 0,
     });
 }
 export function clasificarErrorDelMotor(err) {

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/index.js

@@ -29,6 +29,8 @@ import { releaseKeyboard } from "./ui/interrupt.js";
 import { takeQueued, resetTypeAhead } from "./ui/typeAhead.js";
 import { mcpManager } from "./mcp/manager.js";
 import { comprobarActualizacion } from "./config/updater.js";
+import { comprobarNode } from "./config/nodeVersion.js";
+import { imprimirSobreElPrompt } from "./ui/prompt.js";
 /**
  * Version leida del package.json instalado, no escrita a mano: una constante
  * duplicada aqui se queda vieja en cuanto se publica una version nueva.
@@ -178,6 +180,15 @@ async function dispararStop(hooks, datos) {
     return null;
 }
 async function main() {
+    // Lo primero de todo: un Node viejo se dice claro, no se descubre a base de
+    // errores raros dentro de una dependencia. Ver config/nodeVersion.ts.
+    const nodeViejo = comprobarNode();
+    if (nodeViejo) {
+        console.error(chalk.red(`
+${nodeViejo}
+`));
+        process.exit(EXIT_USO);
+    }
     const rawArgs = process.argv.slice(2);
     if (handleFlags(rawArgs))
         return;
@@ -237,9 +248,13 @@ async function main() {
     // Si tardan, el primer turno los espera; el usuario ya puede escribir.
     const mcpReady = mcpManager.loadAll().then((resumen) => {
         if (resumen) {
-            console.log(chalk.hex("#D97757")("\n🔌 Servidores MCP:"));
-            console.log(resumen);
-            console.log(chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
+            // Con `console.log` esto se escribia ENCIMA del marco del prompt y lo
+            // destrozaba: los servidores tardan, y para cuando contestan el prompt ya
+            // esta dibujado. Se vio asi en una sesion real del usuario:
+            //     ✔ ide (http): 4 herramientasb modo · esc cancelar
+            imprimirSobreElPrompt(chalk.hex("#D97757")("\n🔌 Servidores MCP:") +
+                `\n${resumen}\n` +
+                chalk.gray(`   ${mcpManager.toolCount} herramientas MCP disponibles.\n`));
         }
         return resumen;
     });
@@ -256,11 +271,11 @@ async function main() {
     })
         .then((aviso) => {
         avisoDeActualizacion = aviso;
-        // Se escribe solo si hay algo que decir y el usuario no esta a mitad de
-        // frase: el prompt se redibuja entero en la siguiente tecla, asi que una
-        // linea de mas aqui no rompe el marco.
+        // Llega tarde a proposito, y para entonces el prompt ya suele estar
+        // dibujado: por eso NO se usa console.log, que lo pisaria. Ver
+        // imprimirSobreElPrompt en ui/prompt.ts.
         if (aviso)
-            console.log(chalk.gray(`\n  ⬆ ${aviso}\n`));
+            imprimirSobreElPrompt(chalk.gray(`\n  ⬆ ${aviso}\n`));
         return aviso;
     })
         .catch(() => "");

package/dist/mcp/client.d.ts

@@ -68,7 +68,35 @@ export declare class McpClient {
     private spawnServer;
     private onMessage;
     private request;
+    /**
+     * Identificador de sesion que asigna el servidor HTTP.
+     *
+     * El transporte "streamable HTTP" del protocolo permite que el servidor
+     * devuelva una cabecera `Mcp-Session-Id` al responder al `initialize`, y a
+     * partir de ahi EXIGE que el cliente la mande en todas las peticiones
+     * siguientes. Sin esto, un servidor con sesion acepta el saludo y luego
+     * rechaza absolutamente todo lo demas: la conexion parece buena, la lista de
+     * herramientas llega vacia o con un 400, y desde fuera solo se ve un servidor
+     * que "no funciona" sin decir por que.
+     */
+    private sessionId;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    private cabecerasHttp;
     private notify;
+    /**
+     * Una notificacion por HTTP.
+     *
+     * Antes esto no existia y `notify()` se iba de vacio en cuanto habia una URL,
+     * asi que `notifications/initialized` solo viajaba por stdio. El protocolo la
+     * exige despues del `initialize`, y hay servidores que no atienden nada mas
+     * hasta recibirla: quedaban colgados en el saludo.
+     *
+     * No lleva id y no espera resultado -el servidor contesta 202 con el cuerpo
+     * vacio-, asi que no se parsea nada. Un fallo aqui tampoco se propaga: si el
+     * servidor no la queria, se vera en la peticion siguiente, que si tiene a
+     * quien quejarse.
+     */
+    private httpNotify;
     private httpRequest;
     private initialize;
     private listTools;

package/dist/mcp/client.js

@@ -272,13 +272,62 @@ export class McpClient {
             }
         });
     }
+    /**
+     * Identificador de sesion que asigna el servidor HTTP.
+     *
+     * El transporte "streamable HTTP" del protocolo permite que el servidor
+     * devuelva una cabecera `Mcp-Session-Id` al responder al `initialize`, y a
+     * partir de ahi EXIGE que el cliente la mande en todas las peticiones
+     * siguientes. Sin esto, un servidor con sesion acepta el saludo y luego
+     * rechaza absolutamente todo lo demas: la conexion parece buena, la lista de
+     * herramientas llega vacia o con un 400, y desde fuera solo se ve un servidor
+     * que "no funciona" sin decir por que.
+     */
+    sessionId = null;
+    /** Las mismas cabeceras para peticiones y notificaciones, sesion incluida. */
+    cabecerasHttp() {
+        return {
+            "Content-Type": "application/json",
+            Accept: "application/json, text/event-stream",
+            ...(this.sessionId ? { "Mcp-Session-Id": this.sessionId } : {}),
+            // Las del usuario van al final: si configura una a mano, manda la suya.
+            ...(this.config.headers || {}),
+        };
+    }
     notify(method, params) {
-        if (this.config.url || !this.proc)
-            return;
+        if (this.config.url)
+            return this.httpNotify(method, params);
+        if (!this.proc)
+            return Promise.resolve();
         try {
             this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method, params }) + "\n");
         }
         catch { }
+        return Promise.resolve();
+    }
+    /**
+     * Una notificacion por HTTP.
+     *
+     * Antes esto no existia y `notify()` se iba de vacio en cuanto habia una URL,
+     * asi que `notifications/initialized` solo viajaba por stdio. El protocolo la
+     * exige despues del `initialize`, y hay servidores que no atienden nada mas
+     * hasta recibirla: quedaban colgados en el saludo.
+     *
+     * No lleva id y no espera resultado -el servidor contesta 202 con el cuerpo
+     * vacio-, asi que no se parsea nada. Un fallo aqui tampoco se propaga: si el
+     * servidor no la queria, se vera en la peticion siguiente, que si tiene a
+     * quien quejarse.
+     */
+    async httpNotify(method, params) {
+        try {
+            await fetch(this.config.url, {
+                method: "POST",
+                headers: this.cabecerasHttp(),
+                body: JSON.stringify({ jsonrpc: "2.0", method, params }),
+                signal: AbortSignal.timeout(5000),
+            });
+        }
+        catch { }
     }
     async httpRequest(method, params, timeoutMs) {
         const controller = new AbortController();
@@ -287,14 +336,16 @@ export class McpClient {
         try {
             const res = await fetch(this.config.url, {
                 method: "POST",
-                headers: {
-                    "Content-Type": "application/json",
-                    Accept: "application/json, text/event-stream",
-                    ...(this.config.headers || {}),
-                },
+                headers: this.cabecerasHttp(),
                 body: JSON.stringify({ jsonrpc: "2.0", id, method, params }),
                 signal: controller.signal,
             });
+            // La sesion se apunta ANTES de mirar si la respuesta fue buena: hay
+            // servidores que la asignan y en la misma respuesta se quejan de algo
+            // menor, y tirarla aqui condenaria todas las peticiones siguientes.
+            const sesion = res.headers.get("mcp-session-id");
+            if (sesion)
+                this.sessionId = sesion;
             if (!res.ok)
                 throw new Error(`HTTP ${res.status}`);
             const text = await res.text();
@@ -314,7 +365,10 @@ export class McpClient {
             capabilities: { tools: {} },
             clientInfo: { name: "chocolatito-code", version: "1.0.0" },
         }, timeoutMs);
-        this.notify("notifications/initialized", {});
+        // Se ESPERA a que salga, no se lanza y se olvida. Por HTTP la notificacion
+        // es otra peticion, y si `tools/list` sale antes de que el servidor haya
+        // visto el "ya estoy listo", hay servidores que la rechazan.
+        await this.notify("notifications/initialized", {});
     }
     async listTools(timeoutMs) {
         const out = [];

package/dist/mcp/ide.d.ts

@@ -0,0 +1,76 @@
+import type { McpServerConfig } from "./client.js";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export declare function carpetaDeFichas(): string;
+export interface FichaDeEditor {
+    /** Puerto del servidor MCP de esa ventana. */
+    puerto: number;
+    /** Secreto que hay que presentar en cada peticion. */
+    token: string;
+    /** Carpeta abierta en esa ventana. Es lo que decide cual toca. */
+    carpeta: string;
+    /** Proceso de la ventana, para saber si sigue viva. */
+    pid: number;
+    /** "Visual Studio Code", "Cursor"... solo para poder decirlo por pantalla. */
+    editor?: string;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export declare function estaDentro(hijo: string, padre: string): boolean;
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export declare function leerFichas(dir?: string, limpiar?: boolean): FichaDeEditor[];
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export declare function elegirFicha(cwd: string, fichas: FichaDeEditor[]): FichaDeEditor | null;
+/** La configuracion de servidor MCP que representa a ese editor. */
+export declare function configDeFicha(ficha: FichaDeEditor): McpServerConfig;
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export declare function servidorDelEditor(cwd: string, dir?: string): {
+    config: Record<string, McpServerConfig>;
+    ficha: FichaDeEditor | null;
+};

package/dist/mcp/ide.js

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+/**
+ * Encontrar el editor que hay delante, sin que el usuario configure nada.
+ *
+ * COMO SE HABLAN
+ *
+ * Al reves de lo que parece: la extension del editor es el SERVIDOR MCP y el
+ * agente es el cliente. La extension levanta un servidor en localhost y deja
+ * aqui una ficha con el puerto; el agente la lee al arrancar y se conecta solo.
+ * Asi el editor le presta al agente lo unico que el agente no puede tener por su
+ * cuenta: los diagnosticos del servidor de lenguaje, lo que hay seleccionado, y
+ * un sitio donde pintar los diffs de verdad.
+ *
+ * POR QUE UNA FICHA POR VENTANA Y NO UN PUERTO FIJO
+ *
+ * Porque casi nadie tiene un solo VSCode abierto. Con un puerto fijo, el segundo
+ * que arranca no puede escuchar, y el agente de un proyecto acabaria pintando
+ * sus diffs en la ventana de otro. Cada ventana deja su ficha con su carpeta, y
+ * aqui se elige la que de verdad corresponde al directorio de trabajo.
+ *
+ * SEGURIDAD
+ *
+ * El servidor escucha solo en 127.0.0.1 y la ficha lleva un token que hay que
+ * mandar en cada peticion. Sin eso, cualquier programa de la maquina podria
+ * pedirle al editor del usuario que abriera y modificara archivos. La ficha vive
+ * en el home, que es donde ya viven las credenciales.
+ */
+/** Donde deja su ficha cada ventana del editor. */
+export function carpetaDeFichas() {
+    return path.join(os.homedir(), ".chocolatito", "ide");
+}
+function normalizar(p) {
+    const limpio = path.resolve(p).replace(/[\\/]+$/, "");
+    // Windows no distingue mayusculas en las rutas, y comparar sin normalizar
+    // hace que "C:\Users" y "c:\users" parezcan proyectos distintos.
+    return process.platform === "win32" ? limpio.toLowerCase() : limpio;
+}
+/** Si `hijo` esta dentro de `padre` (o es el mismo). */
+export function estaDentro(hijo, padre) {
+    const h = normalizar(hijo);
+    const p = normalizar(padre);
+    if (h === p)
+        return true;
+    // El separador importa: sin el, "/proyecto-viejo" pasaria por estar dentro de
+    // "/proyecto".
+    return h.startsWith(p + path.sep) || h.startsWith(p + "/");
+}
+/** Si el proceso de esa ventana sigue vivo. Una ficha huerfana no vale. */
+function sigueViva(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        // La senal 0 no manda nada: solo pregunta si existe y si se puede tocar.
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM significa que existe pero es de otro usuario: existe, que es lo que
+        // se preguntaba.
+        return err?.code === "EPERM";
+    }
+}
+function esFicha(x) {
+    return (x &&
+        Number.isInteger(x.puerto) &&
+        x.puerto > 0 &&
+        typeof x.token === "string" &&
+        x.token.length > 0 &&
+        typeof x.carpeta === "string" &&
+        x.carpeta.length > 0);
+}
+/**
+ * Lee las fichas que hay ahora mismo, tirando las de ventanas ya cerradas.
+ *
+ * `limpiar` borra las huerfanas del disco. Se hace de paso, no en un proceso
+ * aparte: si no, se acumulan para siempre y cada arranque tiene que descartar
+ * mas basura.
+ */
+export function leerFichas(dir = carpetaDeFichas(), limpiar = true) {
+    let nombres;
+    try {
+        nombres = fs.readdirSync(dir).filter((n) => n.endsWith(".json"));
+    }
+    catch {
+        return [];
+    }
+    const vivas = [];
+    for (const nombre of nombres) {
+        const completo = path.join(dir, nombre);
+        let ficha;
+        try {
+            ficha = JSON.parse(fs.readFileSync(completo, "utf-8"));
+        }
+        catch {
+            // Una ficha rota no puede impedir encontrar las buenas.
+            continue;
+        }
+        if (!esFicha(ficha))
+            continue;
+        if (!sigueViva(ficha.pid)) {
+            if (limpiar) {
+                try {
+                    fs.unlinkSync(completo);
+                }
+                catch { }
+            }
+            continue;
+        }
+        vivas.push(ficha);
+    }
+    return vivas;
+}
+/**
+ * De todas las ventanas abiertas, la que corresponde a este directorio.
+ *
+ * Nunca devuelve "la primera que haya": si ninguna contiene al directorio de
+ * trabajo, se devuelve null y el agente sigue sin editor. Conectarse a una
+ * ventana ajena seria peor que no conectarse a ninguna, porque los diffs
+ * apareceran en el proyecto equivocado y el usuario los aceptaria sin mirar.
+ *
+ * Cuando varias contienen al directorio (un monorepo abierto entero y un
+ * paquete suyo abierto aparte), gana LA MAS CERCANA: la carpeta mas larga es la
+ * mas especifica.
+ */
+export function elegirFicha(cwd, fichas) {
+    const candidatas = fichas.filter((f) => estaDentro(cwd, f.carpeta));
+    if (candidatas.length === 0)
+        return null;
+    return candidatas.sort((a, b) => normalizar(b.carpeta).length - normalizar(a.carpeta).length)[0];
+}
+/** La configuracion de servidor MCP que representa a ese editor. */
+export function configDeFicha(ficha) {
+    return {
+        type: "http",
+        // Solo el bucle local: nunca la interfaz de red, que expondria el editor
+        // del usuario a cualquiera que comparta su wifi.
+        url: `http://127.0.0.1:${ficha.puerto}/mcp`,
+        headers: { Authorization: `Bearer ${ficha.token}` },
+        // Corto a proposito: es un proceso local. Si no contesta en 5 s es que la
+        // ventana esta colgada, y esperar 20 retrasaria el arranque para nada.
+        timeout: 5000,
+    };
+}
+/**
+ * Lo que hay que anadir a la configuracion MCP por tener un editor delante.
+ *
+ * Devuelve un objeto vacio si no hay ninguno, que es el caso normal de quien usa
+ * solo la terminal: nadie tiene que configurar nada para que esto no le moleste.
+ */
+export function servidorDelEditor(cwd, dir = carpetaDeFichas()) {
+    // Puerta de salida para quien no lo quiera, y para poder reproducir fallos.
+    if (process.env.CHOCOLATITO_SIN_EDITOR === "1")
+        return { config: {}, ficha: null };
+    const ficha = elegirFicha(cwd, leerFichas(dir));
+    if (!ficha)
+        return { config: {}, ficha: null };
+    return { config: { ide: configDeFicha(ficha) }, ficha };
+}

package/dist/mcp/manager.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { McpClient } from "./client.js";
+import { servidorDelEditor } from "./ide.js";
 /**
  * Gestor de servidores MCP.
  *
@@ -49,6 +50,14 @@ export class McpManager {
                 // Un JSON roto no debe impedir arrancar el agente.
             }
         }
+        // El editor que haya delante se anade solo, sin que nadie lo configure. Va
+        // el ultimo a proposito: si el usuario define un servidor llamado "ide" a
+        // mano, gana el suyo. Ver ide.ts.
+        const { config: delEditor } = servidorDelEditor(this.cwd);
+        for (const [name, cfg] of Object.entries(delEditor)) {
+            if (!merged[name])
+                merged[name] = cfg;
+        }
         return merged;
     }
     /** Conecta todos los servidores configurados. Devuelve un resumen legible. */