@getparallel/parx 0.5.0 → 0.7.0

package/dist/cli.js

@@ -6,16 +6,20 @@ import { basename, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { ALIAS_COMANDO, ALIAS_SI_NO, COMANDOS, t, USO } from "./textos.js";
-import { c, colorDeModo, fijarCapacidades, sep, signo, SIMBOLOS } from "./marca.js";
+import { c, capacidades, colorDeModo, fijarCapacidades, sep, signo, sinColor, SIMBOLOS } from "./marca.js";
 import { guardarAjustes, leerAjustes, migrarCarpetaVieja, VERSION } from "./config.js";
 import { MODELO_POR_DEFECTO, MODELOS, modeloDe, nombreDeModelo } from "./modelos.js";
-import { cicloDeMision, compartirMision, correoVisible, crearMision, ErrorDeParallel, leerBandeja, leerConexiones, leerCuenta, leerMisionDeLaCuenta, leerMisiones, leerPlantillas, quienEs, responderBandeja, verMision, } from "./api.js";
+import { cicloDeMision, compartirMision, correoVisible, crearMision, equipo, ErrorDeParallel, leerBandeja, leerConexiones, leerCuenta, leerMisionDeLaCuenta, leerMisiones, leerPlantillas, quienEs, responderBandeja, verMision, } from "./api.js";
 import { abrirNavegador, comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
 import { accionesDeUnaMision, filtrarPorTitulo, hace } from "./comandos.js";
-import { hacerTarea, mensajeDeError, nuevaSesion } from "./agente.js";
+import { hacerTarea, mensajeDeError, nuevaSesion, reiniciarConversacion } from "./agente.js";
 import { deshacerUltimo, permitirCarpeta } from "./herramientas.js";
 import { Registro } from "./registro.js";
 import { Pantalla } from "./ui.js";
+import { Remoto } from "./remoto.js";
+import { VistaPrevia } from "./vista.js";
+import { anadirCarpeta, carpetasDelServicio, instalarServicio, quitarCarpeta, quitarServicio, reiniciarServicio, rutaDelRegistro, servicioEnMarcha, servicioInstalado, servir } from "./servicio.js";
+import { qrEnTexto } from "./qr.js";
 import { acciones, bloqueDeBienvenida, bloqueDeLaPersona, bloqueDeTabla, duracion, Superficie } from "./tui.js";
 import { CONSEJOS, cambiarConsejos, consejo, elegirConsejos, ordenDeConsejos } from "./consejos.js";
 import { anchoDe, recortarMedio } from "./texto.js";
@@ -24,9 +28,9 @@ import { avisarEnElEscritorio, debeAvisar } from "./notificar.js";
 import { copiarAlPortapapeles, escribirInforme, textoParaPegar } from "./informe.js";
 import { objetivoDeMision } from "./mision.js";
 import { ejecutarCarriles, MAX_CARRILES } from "./carriles.js";
-import { spawnSync } from 'node:child_process';
 import { ejecutarBash, textoParaElAgente } from "./bash.js";
-import { comprobarDeFondo, esMasNueva, ordenDeActualizar, rutaDelCli, ultimaPublicada, versionNuevaConocida } from "./actualizar.js";
+import { comprobarDeFondo, ENTRE_COMPROBACIONES_MS, esMasNueva, ordenDeActualizar, rutaDelCli, ultimaPublicada, versionNuevaConocida } from "./actualizar.js";
+import { autoactualizarApagada, confirmarArranque, gestorPermiteAutoactualizar, lanzarLaMasNueva, prepararVersion } from "./versiones.js";
 function opciones() {
     return parseArgs({
         allowPositionals: true,
@@ -46,6 +50,10 @@ function opciones() {
             'no-mouse': { type: 'boolean' },
             'no-animation': { type: 'boolean' },
             animation: { type: 'boolean' },
+            remote: { type: 'boolean' },
+            serve: { type: 'boolean' },
+            'remote-child': { type: 'boolean' },
+            origen: { type: 'string' },
             version: { type: 'boolean', short: 'v' },
             help: { type: 'boolean', short: 'h' },
             browser: { type: 'boolean' },
@@ -70,15 +78,38 @@ function rutaCorta(ruta, max = 48) {
     const corta = ruta.startsWith(casa) ? `~${ruta.slice(casa.length)}` : ruta;
     return recortarMedio(corta, max);
 }
+let lineaDeVersiones = null;
+function novedadParaLaPantalla() {
+    if (lineaDeVersiones)
+        return lineaDeVersiones;
+    if (!autoactualizarApagada())
+        return undefined;
+    const nueva = versionNuevaConocida();
+    return nueva ? t('update.disponible', { version: nueva }) : undefined;
+}
 function cabeceraCorta(lineas = []) {
     process.stdout.write(`\n  ${c.violeta(signo())} ${c.negrita('parx')} ${c.gris(VERSION)}\n`);
-    const nueva = versionNuevaConocida();
-    if (nueva)
-        lineas = [c.gris(t('update.disponible', { version: nueva })), ...lineas];
+    const novedad = novedadParaLaPantalla();
+    if (novedad)
+        lineas = [c.gris(novedad), ...lineas];
     for (const l of lineas)
         process.stdout.write(`     ${l}\n`);
     process.stdout.write('\n');
 }
+async function mantenerAlDia(registro) {
+    try {
+        const nueva = await comprobarDeFondo();
+        if (!nueva || autoactualizarApagada() || !gestorPermiteAutoactualizar(ordenDeActualizar(rutaDelCli()).gestor))
+            return;
+        const r = await prepararVersion(nueva);
+        if (!r.ok)
+            registro?.apuntar('actualizacion', { version: nueva, motivo: r.motivo });
+        else if (!r.yaEstaba)
+            registro?.apuntar('actualizacion', { version: nueva, preparada: true });
+    }
+    catch {
+    }
+}
 export function nombreDeModo(m) {
     return t(`modo.${m}`);
 }
@@ -114,7 +145,7 @@ async function actualizar() {
         process.stdout.write(`${t('update.npx')}\n`);
         return 0;
     }
-    if (gestor === 'desarrollo' || !orden) {
+    if (gestor === 'desarrollo') {
         process.stdout.write(`${t('update.desarrollo')}\n`);
         return 0;
     }
@@ -127,14 +158,13 @@ async function actualizar() {
         process.stdout.write(`${t('update.al_dia', { version: VERSION })}\n`);
         return 0;
     }
-    const texto = orden.map((p) => (/\s/.test(p) ? `"${p}"` : p)).join(' ');
-    process.stdout.write(`${c.gris(t('update.lanzando', { orden: texto }))}\n`);
-    const r = spawnSync(orden[0], orden.slice(1), { stdio: 'inherit', shell: process.platform === 'win32' });
-    if (r.status !== 0) {
-        process.stderr.write(`${c.error('✗')} ${t('update.fallo', { orden: texto })}\n`);
+    const aMano = (orden ?? ['npm', 'install', '-g', '@getparallel/parx@latest']).map((p) => (/\s/.test(p) ? `"${p}"` : p)).join(' ');
+    const r = await prepararVersion(ultima);
+    if (!r.ok) {
+        process.stderr.write(`${c.error('✗')} ${t(r.motivo === 'firma' ? 'update.firma' : 'update.no_se_pudo', { version: ultima, orden: aMano })}\n`);
         return 1;
     }
-    process.stdout.write(`${c.violeta('✓')} ${t('update.hecho')} (${VERSION} → ${ultima})\n`);
+    process.stdout.write(`${c.violeta('✓')} ${t(r.yaEstaba ? 'update.ya_preparada' : 'update.preparada', { version: ultima })}${r.novedad ? c.gris(`${sep()}${r.novedad}`) : ''}\n`);
     return 0;
 }
 async function principal() {
@@ -152,6 +182,9 @@ async function principal() {
         process.stdout.write(`parx ${VERSION}\n`);
         return 0;
     }
+    const estreno = confirmarArranque();
+    if (estreno)
+        lineaDeVersiones = estreno.novedad ? t('update.actualizado_con', { version: estreno.version, novedad: estreno.novedad }) : t('update.actualizado', { version: estreno.version });
     if (v.help) {
         cabeceraCorta();
         process.stdout.write(`${USO}\n`);
@@ -162,7 +195,7 @@ async function principal() {
     const solo = positionals.length === 1 && !v.lanes;
     if (solo && ['update', 'upgrade'].includes(primero))
         return actualizar();
-    void comprobarDeFondo();
+    void mantenerAlDia();
     if (solo && ['login', 'entrar', 'switch'].includes(primero)) {
         cabeceraCorta();
         await entrar((l) => pantalla.escribir(l), { forma: formaPedida(v) });
@@ -194,6 +227,62 @@ async function principal() {
         pantalla.escribir();
         return 0;
     }
+    if (v.serve) {
+        const c0 = credencialesActivas();
+        if (!c0) {
+            console.log(t('cuenta.sin_sesion'));
+            return 1;
+        }
+        return servir(c0);
+    }
+    if (primero === 'service' || primero === 'servicio') {
+        const accion = (positionals[1] ?? 'status').toLowerCase();
+        const ruta = positionals.slice(2).join(' ') || process.cwd();
+        const lista = () => carpetasDelServicio().map((x) => x.nombre).join(', ') || t('servicio.ninguna');
+        if (accion === 'add') {
+            const r = anadirCarpeta(ruta);
+            pantalla.escribir(r ? t('servicio.anadida', { ruta: rutaCorta(r, 60) }) : t('servicio.no_anadida', { ruta }));
+            if (r)
+                reiniciarServicio();
+            return r ? 0 : 1;
+        }
+        if (accion === 'remove') {
+            const ok = quitarCarpeta(positionals.slice(2).join(' '));
+            pantalla.escribir(ok ? t('servicio.quitada', { ruta: positionals.slice(2).join(' ') }) : t('servicio.no_quitada', { ruta: positionals.slice(2).join(' ') }));
+            if (ok)
+                reiniciarServicio();
+            return ok ? 0 : 1;
+        }
+        if (accion === 'on') {
+            if (process.platform !== 'darwin') {
+                pantalla.error(t('servicio.solo_mac'));
+                return 1;
+            }
+            if (!credencialesActivas()) {
+                pantalla.escribir(t('cuenta.sin_sesion'));
+                return 1;
+            }
+            if (!carpetasDelServicio().length && !anadirCarpeta(process.cwd())) {
+                pantalla.escribir(t('servicio.sin_carpetas'));
+                return 1;
+            }
+            instalarServicio();
+            pantalla.escribir(t('servicio.on', { carpetas: lista() }));
+            pantalla.escribir(c.gris(t('servicio.registro', { ruta: rutaDelRegistro() })));
+            return 0;
+        }
+        if (accion === 'off') {
+            quitarServicio();
+            pantalla.escribir(t('servicio.off'));
+            return 0;
+        }
+        if (accion === 'status') {
+            pantalla.escribir(t('servicio.estado', { estado: servicioInstalado() && servicioEnMarcha() ? t('servicio.en_marcha') : t('servicio.parado'), lista: lista() }));
+            return 0;
+        }
+        pantalla.escribir(t('servicio.uso'));
+        return 2;
+    }
     const modoPedido = (v.mode ?? v.modo);
     const pedido = modoDe(modoPedido);
     if (pedido === 'bypass') {
@@ -242,6 +331,8 @@ async function principal() {
         lecturas: [],
         jaula: Boolean(v.sandbox),
     });
+    if (cuenta.tarifa)
+        sesion.tarifas = cuenta.tarifa;
     for (const f of v['add-folder'] ?? []) {
         const ok = permitirCarpeta(sesion.ctx, f);
         if (!ok)
@@ -270,6 +361,26 @@ async function principal() {
     let control = new AbortController();
     let ocupado = false;
     let superficie = null;
+    let remoto = null;
+    let deFueraPendientes = 0;
+    let sugeridaMision = false;
+    let vistaPrevia = new VistaPrevia();
+    const actualizarVista = async (forzar = false) => {
+        const r0 = remoto;
+        if (!r0?.encendido || !r0.id)
+            return null;
+        try {
+            const r = await vistaPrevia.actualizar({ servidor: cred.servidor, token: cred.token, remoto: r0.id, raiz });
+            if (!r)
+                return null;
+            if (r.cambiados > 0 || forzar)
+                r0.evento('vista', { url: r.url, version: r.version, archivos: r.cambiados, carpeta: r.carpeta });
+            return { url: r.url };
+        }
+        catch (e) {
+            return { error: e instanceof ErrorDeParallel ? e.codigo : 'red' };
+        }
+    };
     let bienvenida;
     let consejosDeEntrada = [];
     const confirmarNuevaEnMarcha = async () => {
@@ -283,15 +394,7 @@ async function principal() {
             control.abort();
     };
     const empezarDeNuevo = () => {
-        sesion.conversacion = [];
-        sesion.diario = [];
-        sesion.id = randomUUID();
-        sesion.ultimaTarea = undefined;
-        sesion.ctx.hechos = { ficheros: [], comandos: [] };
-        sesion.ctx.permitidos.clear();
-        sesion.ctx.deshacer.length = 0;
-        if (sesion.ctx.lecturas)
-            sesion.ctx.lecturas.length = 0;
+        reiniciarConversacion(sesion);
         registro.apuntar('nueva', {});
         pantalla.reiniciar();
         if (superficie)
@@ -307,6 +410,14 @@ async function principal() {
             superficie.terminar(despedida());
         else
             pantalla.escribir(despedida());
+        if (remoto?.encendido) {
+            const salida = setTimeout(() => process.exit(0), 1500);
+            void remoto.cerrar().finally(() => {
+                clearTimeout(salida);
+                process.exit(0);
+            });
+            return;
+        }
         process.exit(0);
     };
     const alCtrlC = () => {
@@ -348,6 +459,13 @@ async function principal() {
         superficie?.trabajar(() => control.abort());
         const inicio = Date.now();
         let seguir = true;
+        if (remoto?.encendido) {
+            remoto.fijarModo(nombreDeModo(sesion.ctx.modo), nombreDeModelo(sesion.modelo));
+            remoto.evento('tu', { texto: texto.replace(/^\u2060/, ''), desde: deFueraPendientes > 0 ? 'movil' : 'ordenador' });
+            if (deFueraPendientes > 0)
+                deFueraPendientes--;
+            remoto.fijarEstado('trabajando', texto.replace(/^\u2060/, ''));
+        }
         try {
             seguir = await hacerTarea(sesion, texto, control.signal, imagenes);
             if (sesion.disponibles !== undefined && sesion.disponibles !== null)
@@ -356,10 +474,100 @@ async function principal() {
         finally {
             ocupado = false;
             superficie?.descansar();
+            remoto?.fijarEstado('libre', null);
+        }
+        if (remoto?.encendido)
+            void actualizarVista();
+        if (!sugeridaMision && sesion.diario.some((d) => d.ficheros.length) && superficie) {
+            sugeridaMision = true;
+            soloAqui(() => pantalla.escribir(c.gris(t('mision.sugerencia'))));
         }
         quizaAvisar(t('aviso.termino', { tarea: texto.replace(/\s+/g, ' ').slice(0, 80) }), Date.now() - inicio);
         return seguir;
     };
+    const encenderRemoto = async (enseñarQR = true) => {
+        if (!superficie) {
+            pantalla.escribir(t('remoto.solo_interactiva'));
+            return;
+        }
+        if (remoto?.encendido && remoto.url) {
+            const url = remoto.url;
+            soloAqui(() => enseñarEnlace(url, enseñarQR));
+            return;
+        }
+        const nuevo = new Remoto({
+            servidor: cred.servidor,
+            token: cred.token,
+            alMensaje: (texto) => {
+                soloAqui(() => pantalla.escribir(c.gris(`${t('remoto.del_movil')}:`)));
+                deFueraPendientes++;
+                superficie?.mandarDesdeFuera(texto);
+            },
+            alParar: () => {
+                if (!ocupado)
+                    return;
+                control.abort();
+                pantalla.aviso(t('remoto.parado'));
+            },
+            alApagarse: (motivo) => {
+                pantalla.espejo = null;
+                remoto = null;
+                pantalla.aviso(motivo === 'web' ? t('remoto.cortado_web') : motivo === 'sesion' ? t('remoto.sesion') : t('remoto.no_disponible'));
+                superficie?.pintar();
+            },
+        });
+        try {
+            const r = await nuevo.abrir({ equipo: equipo().equipo, version: equipo().version, carpeta: basename(raiz), modelo: nombreDeModelo(sesion.modelo), modo: nombreDeModo(sesion.ctx.modo) });
+            remoto = nuevo;
+            vistaPrevia = new VistaPrevia();
+            registro.apuntar('remoto', { encendido: true });
+            enseñarEnlace(r.url, enseñarQR);
+            pantalla.espejo = nuevo;
+        }
+        catch (e) {
+            if (e instanceof ErrorDeParallel) {
+                if (e.codigo === 'sin_acceso')
+                    pantalla.error(t('remoto.no_disponible'));
+                else if (e.codigo === 'sesion')
+                    pantalla.error(t('remoto.sesion'));
+                else if (e.detalle.includes('demasiados'))
+                    pantalla.error(t('remoto.demasiados'));
+                else
+                    pantalla.error(t('remoto.sin_red', { motivo: e.codigo === 'red' ? 'no connection' : e.detalle || e.codigo }));
+            }
+            else
+                throw e;
+        }
+        superficie?.pintar();
+    };
+    const soloAqui = (f) => {
+        const e = pantalla.espejo;
+        pantalla.espejo = null;
+        try {
+            f();
+        }
+        finally {
+            pantalla.espejo = e;
+        }
+    };
+    const enseñarEnlace = (url, conQR) => {
+        pantalla.escribir(t('remoto.on', { url: c.marca(url) }));
+        pantalla.escribir(c.gris(t('remoto.detalle')));
+        const caps = capacidades();
+        const qr = conQR ? qrEnTexto(url, { color: caps.color > 0, unicode: caps.unicode }) : null;
+        if (qr && caps.ancho >= sinColor(qr[0]).length + 4) {
+            pantalla.escribir(c.gris(t('remoto.escanea')));
+            pantalla.bloque(() => ['', ...qr.map((l) => `  ${l}`), '']);
+        }
+    };
+    const apagarRemoto = async () => {
+        const r = remoto;
+        remoto = null;
+        pantalla.espejo = null;
+        if (r)
+            await r.cerrar();
+        registro.apuntar('remoto', { encendido: false });
+    };
     const carriles = async (tareas) => {
         if (tareas.length < 2) {
             pantalla.escribir(t('carriles.min'));
@@ -407,6 +615,63 @@ async function principal() {
         quizaAvisar(t('carriles.hecho', { n: tareas.length }), ms);
         return r.ok;
     };
+    if (v['remote-child']) {
+        const cola = [];
+        let despertar = null;
+        let cortada = false;
+        const r = new Remoto({
+            servidor: cred.servidor,
+            token: cred.token,
+            alMensaje: (texto) => {
+                cola.push(texto);
+                despertar?.();
+            },
+            alParar: () => {
+                if (ocupado)
+                    control.abort();
+            },
+            alApagarse: () => {
+                cortada = true;
+                if (ocupado)
+                    control.abort();
+                despertar?.();
+            },
+        });
+        const e = equipo();
+        try {
+            await r.abrir({ equipo: e.equipo, version: e.version, carpeta: basename(raiz), modelo: nombreDeModelo(sesion.modelo), modo: nombreDeModo(sesion.ctx.modo), ...(typeof v.origen === 'string' ? { origen: v.origen } : {}) });
+        }
+        catch {
+            return 1;
+        }
+        remoto = r;
+        pantalla.espejo = r;
+        if (tarea) {
+            deFueraPendientes++;
+            await hacer(tarea);
+        }
+        const INACTIVA_MS = 30 * 60 * 1000;
+        while (!cortada) {
+            const siguiente = cola.shift();
+            if (siguiente) {
+                deFueraPendientes++;
+                await hacer(siguiente);
+                continue;
+            }
+            const hubo = await new Promise((res) => {
+                const reloj = setTimeout(() => res(false), INACTIVA_MS);
+                despertar = () => {
+                    clearTimeout(reloj);
+                    res(true);
+                };
+            });
+            despertar = null;
+            if (!hubo)
+                break;
+        }
+        await r.cerrar();
+        return 0;
+    }
     if (tarea) {
         cabeceraCorta([c.gris([nombreDeModo(modo), nombreDeModelo(modelo), cuenta.plan, rutaCorta(raiz)].filter(Boolean).join(sep()))]);
         if (quiereBypass && (await confirmarBypass()))
@@ -507,15 +772,14 @@ async function principal() {
             quien: quien.includes('@') ? quien : (quien.split(/\s+/)[0] ?? ''),
             carpeta: rutaCorta(raiz, 60),
             plan: cuenta.plan,
-            novedad: (() => {
-                const nueva = versionNuevaConocida();
-                return nueva ? t('update.disponible', { version: nueva }) : undefined;
-            })(),
+            novedad: novedadParaLaPantalla(),
             peligro: () => sesion.ctx.modo === 'bypass',
         });
         superficie.iniciar(bienvenida, consejosDeEntrada);
         if (quiereBypass)
             await confirmarBypass();
+        if (v.remote || ajustes.remoto)
+            void encenderRemoto(Boolean(v.remote));
         const mirarBandeja = async () => {
             if (ocupado)
                 return;
@@ -536,6 +800,11 @@ async function principal() {
         relojBandeja.unref();
         void mirarBandeja();
         void cargarConexiones();
+        const relojVersiones = setInterval(() => {
+            if (!ocupado)
+                void mantenerAlDia(registro);
+        }, ENTRE_COMPROBACIONES_MS);
+        relojVersiones.unref();
     }
     const leerLinea = async (ejemplo = null) => {
         if (superficie)
@@ -962,7 +1231,7 @@ async function principal() {
                     break;
                 }
                 case 'mission': {
-                    const objetivo = objetivoDeMision(resto, sesion.diario);
+                    const objetivo = objetivoDeMision(resto, sesion.diario, vistaPrevia.url);
                     if (!objetivo) {
                         pantalla.escribir(t('mision.nada'));
                         break;
@@ -1053,6 +1322,47 @@ async function principal() {
                     pantalla.escribir(pantalla.animar ? t('animacion.on') : t('animacion.off'));
                     break;
                 }
+                case 'remote': {
+                    if (arg === 'off' || ALIAS_SI_NO[arg] === 'no' || arg === 'never') {
+                        await apagarRemoto();
+                        if (leerAjustes().remoto)
+                            guardarAjustes({ remoto: false });
+                        pantalla.escribir(t('remoto.off'));
+                        superficie?.pintar();
+                        break;
+                    }
+                    if (arg === 'always' || arg === 'siempre') {
+                        guardarAjustes({ remoto: true });
+                        await encenderRemoto(true);
+                        pantalla.escribir(c.gris(t('remoto.siempre')));
+                        break;
+                    }
+                    await encenderRemoto(true);
+                    break;
+                }
+                case 'preview': {
+                    if (!remoto?.encendido) {
+                        pantalla.escribir(t('vista.sin_remoto'));
+                        break;
+                    }
+                    const r = await actualizarVista(true);
+                    if (!r)
+                        pantalla.escribir(t('vista.sin_web'));
+                    else if ('error' in r)
+                        pantalla.error(t('vista.no_subida', { motivo: r.error }));
+                    else
+                        pantalla.escribir(t('vista.lista', { url: c.marca(r.url) }));
+                    break;
+                }
+                case 'autoupdate': {
+                    const si = ALIAS_SI_NO[arg] ?? (autoactualizarApagada() ? 'si' : 'no');
+                    guardarAjustes({ autoactualizar: si === 'si' });
+                    registro.apuntar('autoactualizar', { encendido: si === 'si' });
+                    pantalla.escribir(si === 'si' ? t('autoupdate.on') : t('autoupdate.off'));
+                    if (si === 'si')
+                        void mantenerAlDia(registro);
+                    break;
+                }
                 case 'undo': {
                     const r2 = deshacerUltimo(sesion.ctx);
                     pantalla.escribir(r2 ? t('repl.deshecho', { ruta: r2 }) : t('repl.nada_que_deshacer'));
@@ -1112,10 +1422,16 @@ async function principal() {
     return 0;
 }
 if (!process.env.PARX_PRUEBAS) {
-    principal().then((codigo) => process.exit(codigo), (e) => {
-        if (e instanceof ErrorDeParallel && e.codigo === 'interrumpido')
-            process.exit(130);
-        process.stderr.write(`${c.error('✗')} ${e instanceof ErrorDeParallel ? mensajeDeError(e) : e instanceof Error ? e.message : String(e)}\n`);
-        process.exit(1);
+    lanzarLaMasNueva().then((lanzamiento) => {
+        if (lanzamiento.lanzada)
+            return;
+        if (lanzamiento.retirada)
+            lineaDeVersiones = t('update.no_arranco', { version: lanzamiento.retirada, actual: VERSION });
+        principal().then((codigo) => process.exit(codigo), (e) => {
+            if (e instanceof ErrorDeParallel && e.codigo === 'interrumpido')
+                process.exit(130);
+            process.stderr.write(`${c.error('✗')} ${e instanceof ErrorDeParallel ? mensajeDeError(e) : e instanceof Error ? e.message : String(e)}\n`);
+            process.exit(1);
+        });
     });
 }

package/dist/config.js

@@ -96,6 +96,12 @@ export function leerAjustes(dir = carpetaDeConfiguracion()) {
             out.raton = a.raton;
         if (typeof a.animacion === 'boolean')
             out.animacion = a.animacion;
+        if (typeof a.autoactualizar === 'boolean')
+            out.autoactualizar = a.autoactualizar;
+        if (typeof a.remoto === 'boolean')
+            out.remoto = a.remoto;
+        if (Array.isArray(a.carpetasRemotas))
+            out.carpetasRemotas = a.carpetasRemotas.filter((x) => typeof x === 'string').slice(0, 20);
         const k = a.consejos;
         if (k && typeof k === 'object') {
             const n = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);

package/dist/estimacion.js

@@ -0,0 +1,118 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion } from "./config.js";
+import { MODELOS, ORDEN_DE_MODELOS, nombreDeModelo } from "./modelos.js";
+import { t } from "./textos.js";
+export const PERFILES = {
+    pregunta: { vueltas: 2, crecimiento: 700, salidaPorVuelta: 80, salidaFinal: 350 },
+    pequena: { vueltas: 4, crecimiento: 900, salidaPorVuelta: 350, salidaFinal: 200 },
+    media: { vueltas: 8, crecimiento: 1200, salidaPorVuelta: 550, salidaFinal: 250 },
+    grande: { vueltas: 16, crecimiento: 1500, salidaPorVuelta: 650, salidaFinal: 350 },
+};
+const GRANDE = /\b(refactor|refactoriz|migrat|migra[r]?\b|rewrite|reescrib|rework|whole (project|app|codebase|repo)|entire|todo el (proyecto|código|repo)|toda la (app|aplicación)|all (the )?files|todos los ficheros|architecture|arquitectura|from scratch|desde cero|full[- ]stack|authentication|autenticaci|database|base de datos|deploy|despliega|integrat|integra[r]?\b|test suite|end[- ]to[- ]end|e2e|multi[- ]?page|varias páginas|dashboard|backend|api rest|microservic)/i;
+const CREA = /\b(create|build|make|write|generate|implement|crea[r]?|construye|monta|escribe|genera|implementa|haz(me)?|new|nuev[oa])\b/i;
+const SUSTANCIAL = /\b(page|página|pagina|website|web ?site|site|web|app|form|formulario|component|componente|feature|funcionalidad|endpoint|screen|pantalla|module|módulo|modulo|api|script|server|servidor|service|servicio|table|tabla|model|modelo|view|vista)\b/i;
+const PEQUENA = /\b(typo|errata|rename|renombra|one[- ]line|una línea|small|pequeñ|minor|mínim|quick|rápid|simple|sencill|tiny|just|solo|sólo|only|fix the|arregla el|arregla la|change the|cambia el|cambia la|add a |añade un|añade una|remove the|quita el|quita la|update the|actualiza el)\b/i;
+const PREGUNTA = /^(what|why|how|where|which|who|when|is|are|does|do|can|could|should|explain|describe|tell me|show me|list|qué|que|por qué|cómo|como|dónde|donde|cuál|cual|quién|quien|cuándo|explica|describe|dime|enséñame|lista|hay)\b/i;
+function palabras(s) {
+    return s.trim().split(/\s+/).filter(Boolean).length;
+}
+export function clasificarTarea(pedido) {
+    const s = pedido.replace(/\s+/g, ' ').trim();
+    const n = palabras(s);
+    if (!s)
+        return 'pequena';
+    if (GRANDE.test(s) || n > 90)
+        return 'grande';
+    const pregunta = PREGUNTA.test(s) || (s.endsWith('?') && !CREA.test(s));
+    if (pregunta && !CREA.test(s))
+        return 'pregunta';
+    const creaAlgo = CREA.test(s) || SUSTANCIAL.test(s);
+    if (n <= 10 && !creaAlgo)
+        return 'pequena';
+    if (PEQUENA.test(s) && !creaAlgo)
+        return 'pequena';
+    return 'media';
+}
+export function tokensDe(texto) {
+    const chars = typeof texto === 'number' ? texto : texto.length;
+    return Math.ceil(chars / 3.8);
+}
+export function accionesEnBruto(clase, baseTokens, tarifa) {
+    const p = PERFILES[clase];
+    let entrada = 0;
+    let salida = 0;
+    for (let i = 0; i < p.vueltas; i++) {
+        entrada += baseTokens + i * p.crecimiento;
+        salida += i === p.vueltas - 1 ? p.salidaFinal : p.salidaPorVuelta;
+    }
+    return (entrada * tarifa.entrada + salida * tarifa.salida) / 1000;
+}
+export function redondear(n) {
+    if (n < 1)
+        return 1;
+    if (n < 10)
+        return Math.round(n);
+    const magnitud = 10 ** (Math.floor(Math.log10(n)) - 1);
+    return Math.round(n / magnitud) * magnitud;
+}
+export function estimarTarea(e) {
+    const clase = clasificarTarea(e.pedido);
+    const base = tokensDe(e.contextoChars) + tokensDe(e.pedido);
+    const acciones = {};
+    for (const m of ORDEN_DE_MODELOS) {
+        const bruto = accionesEnBruto(clase, base, e.tarifas[MODELOS[m].servidor]);
+        acciones[m] = redondear(bruto * factorDeCalibracion(e.calibracion, clase, m));
+    }
+    return { clase, acciones };
+}
+export function lineaDeEstimacion(est, modelo) {
+    const actual = est.acciones[modelo];
+    let sugerido = null;
+    if (modelo === 'summit' && est.clase !== 'grande')
+        sugerido = 'stride';
+    if ((modelo === 'summit' || modelo === 'stride') && (est.clase === 'pregunta' || est.clase === 'pequena'))
+        sugerido = 'swift';
+    if (sugerido && est.acciones[sugerido] <= actual * 0.6 && actual >= 5) {
+        return t('estimacion.con', { n: actual.toLocaleString('en-US'), modelo: nombreDeModelo(sugerido).replace(/ \d+(\.\d+)?$/, ''), otro: est.acciones[sugerido].toLocaleString('en-US') });
+    }
+    return t('estimacion.linea', { n: actual.toLocaleString('en-US') });
+}
+const FICHERO = 'estimaciones.json';
+const PESO = 0.3;
+export function leerCalibracion(dir = carpetaDeConfiguracion()) {
+    try {
+        const c = JSON.parse(readFileSync(join(dir, FICHERO), 'utf8'));
+        return c && typeof c === 'object' ? c : {};
+    }
+    catch {
+        return {};
+    }
+}
+function guardarCalibracion(c, dir) {
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(dir, FICHERO), JSON.stringify(c, null, 2), { mode: 0o600 });
+    }
+    catch {
+    }
+}
+export function factorDeCalibracion(c, clase, modelo) {
+    const f = c?.[clase]?.[modelo]?.factor;
+    if (typeof f !== 'number' || !Number.isFinite(f) || f <= 0)
+        return 1;
+    return Math.min(2, Math.max(0.5, f));
+}
+export function aprenderDeLaTarea(o) {
+    const dir = o.dir ?? carpetaDeConfiguracion();
+    const c = o.calibracion ?? leerCalibracion(dir);
+    if (!(o.estimada > 0) || !(o.real > 0))
+        return c;
+    const ratio = Math.min(4, Math.max(0.25, o.real / o.estimada));
+    const antes = c[o.clase]?.[o.modelo];
+    const factor = antes ? antes.factor * (1 - PESO) + ratio * PESO : ratio;
+    c[o.clase] = { ...(c[o.clase] ?? {}), [o.modelo]: { factor: Number(factor.toFixed(3)), n: (antes?.n ?? 0) + 1 } };
+    guardarCalibracion(c, dir);
+    return c;
+}