chocolatito-code 1.6.12 → 1.6.14

package/dist/servidor/archivos.js

@@ -0,0 +1,156 @@
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * ARCHIVOS QUE ENTRAN Y ARCHIVOS QUE SALEN
+ *
+ * DE DONDE SALE
+ *
+ * La pagina de `--servir` solo sabia texto. Ni un `<input type=file>`, ni una
+ * sola `<img>`. Y eso deja el ciclo de trabajo cojo por los dos extremos:
+ *
+ *  - Lo que tienes en el movil -la foto, el video que te mando el cliente, la
+ *    captura del error- no hay forma de metarlo. Habia que pasarlo antes al PC.
+ *  - Lo que el agente produce se contesta con la RUTA. En un movil, "lo tienes
+ *    en C:\Users\...\salida\pieza-01.png" no sirve para nada: no puedes mirarlo,
+ *    asi que no puedes opinar, asi que no puedes trabajar.
+ *
+ * LAS DOS REGLAS
+ *
+ *  1. LO QUE ENTRA CAE EN UN SOLO SITIO: `entradas/` de la carpeta de trabajo.
+ *     No se deja elegir destino. Un nombre de archivo que llega por la red no
+ *     es un nombre: es lo que alguien escribio al otro lado, y "..\..\.ssh\id_rsa"
+ *     tambien es un nombre. Se le quita todo lo que parezca una ruta y se queda
+ *     el nombre pelado.
+ *
+ *  2. LO QUE SALE NO PUEDE SALIRSE DE LA CARPETA DE TRABAJO. Se resuelve la
+ *     ruta de verdad -con enlaces simbolicos ya seguidos- y se comprueba que
+ *     sigue estando dentro. Sin eso, `?ruta=../../.chocolatitorc` serviria la
+ *     clave de API por HTTP a quien tenga el enlace.
+ *
+ * Las dos comprobaciones viven aqui y no en el servidor a proposito: son la
+ * clase de cosa que se copia mal cuando se reparte entre tres sitios.
+ */
+/** Lo mas grande que se acepta de una vez. Un video de movil cabe de sobra. */
+export const LIMITE_DE_SUBIDA = 64 * 1024 * 1024;
+/** Donde caen los archivos que llegan del navegador. */
+export const CARPETA_DE_ENTRADAS = "entradas";
+const TIPOS = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".bmp": "image/bmp",
+    ".avif": "image/avif",
+    ".pdf": "application/pdf",
+    ".mp4": "video/mp4",
+    ".webm": "video/webm",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".ogg": "audio/ogg",
+    ".txt": "text/plain; charset=utf-8",
+    ".md": "text/plain; charset=utf-8",
+    ".json": "application/json",
+    ".csv": "text/csv; charset=utf-8",
+};
+export function tipoDelArchivo(ruta) {
+    return TIPOS[path.extname(ruta).toLowerCase()] || "application/octet-stream";
+}
+export function esImagen(ruta) {
+    return tipoDelArchivo(ruta).startsWith("image/");
+}
+/**
+ * Deja un nombre de archivo en algo que no pueda salirse de su carpeta.
+ *
+ * No vale con quitar "..": en Windows tambien separa la barra invertida, y
+ * "C:algo" es una ruta relativa al disco C. Se parte por los dos separadores y
+ * se toma el ultimo trozo, que es lo unico que de verdad es un nombre.
+ */
+export function nombreSeguro(propuesto) {
+    const ultimo = String(propuesto || "")
+        .split(/[\\/]/)
+        .pop()
+        .replace(/^\.+/, "") // nada de ".." ni de archivos ocultos por accidente
+        .replace(/[\x00-\x1f<>:"|?*]/g, "") // lo que Windows no admite, y los de control
+        .trim();
+    const limpio = ultimo.slice(0, 120);
+    return limpio || `archivo-${Date.now()}`;
+}
+/** Si ya existe, se numera en vez de pisar lo que hubiera. */
+export function rutaLibre(carpeta, nombre) {
+    const ext = path.extname(nombre);
+    const base = path.basename(nombre, ext);
+    let intento = path.join(carpeta, nombre);
+    let n = 2;
+    while (fs.existsSync(intento)) {
+        intento = path.join(carpeta, `${base}-${n}${ext}`);
+        n++;
+        if (n > 9999)
+            return path.join(carpeta, `${base}-${Date.now()}${ext}`);
+    }
+    return intento;
+}
+export function guardarSubida(cwd, nombrePropuesto, datos) {
+    if (datos.length === 0)
+        return { ok: false, error: "El archivo llego vacio." };
+    if (datos.length > LIMITE_DE_SUBIDA) {
+        return { ok: false, error: `El archivo pasa de ${Math.round(LIMITE_DE_SUBIDA / 1024 / 1024)} MB.` };
+    }
+    try {
+        const carpeta = path.join(cwd, CARPETA_DE_ENTRADAS);
+        fs.mkdirSync(carpeta, { recursive: true });
+        const destino = rutaLibre(carpeta, nombreSeguro(nombrePropuesto));
+        fs.writeFileSync(destino, datos);
+        return { ok: true, ruta: destino };
+    }
+    catch (err) {
+        return { ok: false, error: err?.message || String(err) };
+    }
+}
+/**
+ * Comprueba que una ruta pedida por el navegador se puede servir.
+ *
+ * Devuelve la ruta real o null. Null es un 404 siempre, tambien cuando el
+ * archivo existe pero esta fuera: decir "existe pero no te lo doy" ya es contar
+ * algo del disco de alguien a quien no le hemos preguntado.
+ */
+export function rutaServible(cwd, pedida) {
+    if (!pedida)
+        return null;
+    try {
+        const absoluta = path.isAbsolute(pedida) ? pedida : path.resolve(cwd, pedida);
+        // realpath ANTES de comparar: si no, un enlace simbolico dentro de la
+        // carpeta apuntando a C:\Users\... pasaria la comprobacion y serviria
+        // cualquier cosa del disco.
+        const real = fs.realpathSync(absoluta);
+        const raiz = fs.realpathSync(cwd);
+        const dentro = real === raiz || real.startsWith(raiz + path.sep);
+        if (!dentro)
+            return null;
+        if (!fs.statSync(real).isFile())
+            return null;
+        return real;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * La linea que se le mete a la conversacion cuando llegan archivos.
+ *
+ * Lleva las rutas COMPLETAS y no los nombres: el modelo tiene que poder
+ * abrirlos sin adivinar donde cayeron, y "la foto que acabo de subir" no es una
+ * ruta. Y se dice que vienen del navegador, porque cambia lo que hay que hacer
+ * con ellos: no son archivos del proyecto, son material que acaba de llegar.
+ */
+export function avisoDeSubida(rutas) {
+    if (rutas.length === 0)
+        return "";
+    if (rutas.length === 1)
+        return `[El usuario subio un archivo desde el navegador: ${rutas[0]}]`;
+    return (`[El usuario subio ${rutas.length} archivos desde el navegador:\n` +
+        rutas.map((r) => `- ${r}`).join("\n") +
+        "]");
+}

package/dist/servidor/fondo.d.ts

@@ -0,0 +1,85 @@
+/**
+ * LA SESION QUE SOBREVIVE AL TERMINAL
+ *
+ * DE DONDE SALE
+ *
+ * `--servir` ya ponia la sesion en el navegador del movil, pero seguia colgando
+ * de la ventana del terminal: si se cerraba -o se cerraba el portatil, o se
+ * reiniciaba la maquina- la sesion moria con ella. O sea que para trabajar desde
+ * el telefono habia que dejar una ventana negra abierta en el PC y no tocarla,
+ * que es justo la clase de cosa que se cierra sin querer.
+ *
+ * Con `--servir --fondo` el proceso se suelta del terminal: arranca, imprime el
+ * enlace, y la ventana se puede cerrar. La sesion sigue viva con el navegador
+ * como unica interfaz.
+ *
+ * POR QUE UN ARCHIVO Y NO UN PUERTO FIJO
+ *
+ * Para volver a entrar hace falta saber tres cosas: en que puerto escucha, con
+ * que token, y si sigue viva. Un puerto fijo no dice lo segundo ni lo tercero.
+ * Se guardan en `~/.chocolatito/sesion-web.json`, al lado de la clave de API y
+ * con los mismos permisos que el resto de la configuracion del usuario.
+ *
+ * Y SE COMPRUEBA QUE SIGUE VIVA, NO SE DA POR HECHO
+ *
+ * Un archivo con un PID dentro no es una sesion: es un archivo. El proceso pudo
+ * morir de mil formas que no pasan por borrarlo -un apagon, un cierre forzoso,
+ * una actualizacion de Windows-, y entonces `--parar` mataria a quien hubiera
+ * heredado ese numero, que en un PC encendido varios dias es cualquiera. Antes
+ * de creerse nada se pregunta al sistema si ese PID existe.
+ */
+export interface SesionEnFondo {
+    pid: number;
+    puerto: number;
+    token: string;
+    url: string;
+    carpeta: string;
+    desde: string;
+    /** Si se abrio con --servir-red y por tanto se ve desde el movil. */
+    enRed: boolean;
+}
+export declare function rutaDeLaSesion(home?: string): string;
+export declare function guardarSesion(datos: SesionEnFondo, home?: string): void;
+export declare function olvidarSesion(home?: string): void;
+/**
+ * Si un proceso existe.
+ *
+ * `process.kill(pid, 0)` no mata nada: pregunta. Devuelve sin error si el
+ * proceso esta ahi, ESRCH si no existe, y EPERM si existe pero es de otro
+ * usuario -que para lo que nos importa tambien es "existe"-.
+ */
+export declare function procesoVivo(pid: number, matar?: (p: number, s: number) => void): boolean;
+/** La sesion de fondo, solo si de verdad sigue viva. */
+export declare function sesionViva(home?: string, vivo?: (pid: number) => boolean): SesionEnFondo | null;
+/**
+ * Se relanza a si mismo, suelto del terminal.
+ *
+ * `detached` + `stdio: ignore` + `unref` son las tres piezas, y las tres hacen
+ * falta: sin detached el hijo muere con el padre en Unix; sin ignorar la salida
+ * el hijo se bloquea en cuanto llene el buffer de una tuberia que ya no lee
+ * nadie; y sin unref el padre se queda esperando al hijo y el terminal no vuelve.
+ */
+export declare function lanzarEnFondo(argumentos: string[], opciones?: {
+    ejecutable?: string;
+    guion?: string;
+    cwd?: string;
+}): number;
+/**
+ * Para la sesion de fondo. Devuelve que se hizo, en palabras.
+ *
+ * En Windows se mata el arbol entero con taskkill /T: el proceso de Node puede
+ * tener debajo un powershell.exe del control del ordenador o un Chrome del
+ * navegador, y matar solo al padre los deja huerfanos comiendo memoria.
+ */
+export declare function pararSesion(home?: string, opciones?: {
+    esWindows?: boolean;
+    ejecutar?: (cmd: string, args: string[]) => {
+        ok: boolean;
+        detalle: string;
+    };
+    matar?: (pid: number) => void;
+    vivo?: (pid: number) => boolean;
+}): Promise<{
+    ok: boolean;
+    mensaje: string;
+}>;

package/dist/servidor/fondo.js

@@ -0,0 +1,134 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
+export function rutaDeLaSesion(home = os.homedir()) {
+    return path.join(home, ".chocolatito", "sesion-web.json");
+}
+export function guardarSesion(datos, home) {
+    const ruta = rutaDeLaSesion(home);
+    fs.mkdirSync(path.dirname(ruta), { recursive: true });
+    fs.writeFileSync(ruta, JSON.stringify(datos, null, 2), "utf-8");
+}
+export function olvidarSesion(home) {
+    try {
+        fs.rmSync(rutaDeLaSesion(home), { force: true });
+    }
+    catch { }
+}
+/**
+ * Si un proceso existe.
+ *
+ * `process.kill(pid, 0)` no mata nada: pregunta. Devuelve sin error si el
+ * proceso esta ahi, ESRCH si no existe, y EPERM si existe pero es de otro
+ * usuario -que para lo que nos importa tambien es "existe"-.
+ */
+export function procesoVivo(pid, matar = process.kill) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        matar(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === "EPERM";
+    }
+}
+/** La sesion de fondo, solo si de verdad sigue viva. */
+export function sesionViva(home, vivo = (p) => procesoVivo(p)) {
+    try {
+        const datos = JSON.parse(fs.readFileSync(rutaDeLaSesion(home), "utf-8"));
+        if (!datos?.pid || !vivo(datos.pid)) {
+            // El archivo sobrevivio al proceso. Se limpia aqui para que el siguiente
+            // arranque no tenga que decidir otra vez sobre un fantasma.
+            olvidarSesion(home);
+            return null;
+        }
+        return datos;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Se relanza a si mismo, suelto del terminal.
+ *
+ * `detached` + `stdio: ignore` + `unref` son las tres piezas, y las tres hacen
+ * falta: sin detached el hijo muere con el padre en Unix; sin ignorar la salida
+ * el hijo se bloquea en cuanto llene el buffer de una tuberia que ya no lee
+ * nadie; y sin unref el padre se queda esperando al hijo y el terminal no vuelve.
+ */
+export function lanzarEnFondo(argumentos, opciones = {}) {
+    const ejecutable = opciones.ejecutable || process.execPath;
+    const guion = opciones.guion || process.argv[1];
+    const hijo = spawn(ejecutable, [guion, ...argumentos], {
+        cwd: opciones.cwd || process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+        env: { ...process.env, CHOCOLATITO_EN_FONDO: "1" },
+    });
+    hijo.unref();
+    return hijo.pid ?? 0;
+}
+/**
+ * Para la sesion de fondo. Devuelve que se hizo, en palabras.
+ *
+ * En Windows se mata el arbol entero con taskkill /T: el proceso de Node puede
+ * tener debajo un powershell.exe del control del ordenador o un Chrome del
+ * navegador, y matar solo al padre los deja huerfanos comiendo memoria.
+ */
+export async function pararSesion(home, opciones = {}) {
+    // Quien decide si un PID vive se inyecta ARRIBA y se usa en los dos sitios:
+    // al leer la ficha y al comprobar despues. Con la comprobacion de verdad en la
+    // primera y la inyectada en la segunda, la funcion contestaba una cosa u otra
+    // segun si ese numero de proceso existia por casualidad en la maquina que
+    // corriera las pruebas.
+    const vivo = opciones.vivo || ((pid) => procesoVivo(pid));
+    const esWindows = opciones.esWindows ?? process.platform === "win32";
+    const sesion = sesionViva(home, vivo);
+    if (!sesion) {
+        return { ok: false, mensaje: "No hay ninguna sesion de fondo abierta." };
+    }
+    try {
+        if (esWindows) {
+            // spawnSync Y NO spawn. La primera version lanzaba taskkill sin esperarlo
+            // y salia con process.exit() en la linea siguiente: el hijo no llegaba a
+            // arrancar, el archivo de sesion se borraba, y el programa anunciaba
+            // "Sesion detenida" con la sesion contestando en el puerto tan tranquila.
+            // Se vio en la prueba de verdad: --parar decia que si, y la pagina seguia
+            // dando 200.
+            const ejecutar = opciones.ejecutar ||
+                ((cmd, args) => {
+                    const r = spawnSync(cmd, args, { windowsHide: true, encoding: "utf-8" });
+                    return { ok: r.status === 0, detalle: String(r.stderr || r.stdout || "").trim() };
+                });
+            // /T mata el arbol: debajo puede haber un powershell del control del
+            // ordenador o un Chrome del navegador, y matar solo al padre los deja
+            // huerfanos comiendo memoria.
+            ejecutar("taskkill", ["/pid", String(sesion.pid), "/T", "/F"]);
+        }
+        else {
+            const matar = opciones.matar || ((pid) => process.kill(-pid, "SIGTERM"));
+            matar(sesion.pid);
+        }
+    }
+    catch {
+        // Si ya no estaba, el resultado es el que buscabamos. Se comprueba abajo.
+    }
+    // No se cree lo que diga el comando: se mira si el proceso sigue ahi. Es la
+    // unica forma de no volver a mentir.
+    for (let intento = 0; intento < 20 && vivo(sesion.pid); intento++) {
+        await new Promise((r) => setTimeout(r, 100));
+    }
+    if (vivo(sesion.pid)) {
+        // El archivo se queda: la sesion existe, asi que --estado tiene que seguir
+        // encontrandola para poder intentarlo otra vez o matarla a mano.
+        return {
+            ok: false,
+            mensaje: `No se pudo detener la sesion (pid ${sesion.pid}). Sigue abierta en ${sesion.url}`,
+        };
+    }
+    olvidarSesion(home);
+    return { ok: true, mensaje: `Sesion de fondo detenida (pid ${sesion.pid}).` };
+}