@getparallel/parx 0.4.4 → 0.6.0

package/dist/cli.js

@@ -6,15 +6,18 @@ 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 { correoVisible, crearMision, ErrorDeParallel, leerBandeja, leerCuenta, quienEs, responderBandeja, verMision } from "./api.js";
-import { comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
-import { hacerTarea, mensajeDeError, nuevaSesion } from "./agente.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, 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 { 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";
@@ -23,9 +26,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,
@@ -45,6 +48,7 @@ function opciones() {
             'no-mouse': { type: 'boolean' },
             'no-animation': { type: 'boolean' },
             animation: { type: 'boolean' },
+            remote: { type: 'boolean' },
             version: { type: 'boolean', short: 'v' },
             help: { type: 'boolean', short: 'h' },
             browser: { type: 'boolean' },
@@ -69,15 +73,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}`);
 }
@@ -92,7 +119,7 @@ export function modosEnColor() {
     return `${nombres.slice(0, 3).join(', ')} or ${nombres[3]}`;
 }
 function ayudaDeComandos() {
-    return bloqueDeTabla([['!', t('tip.bash')], ...COMANDOS.map(([k, d]) => [`/${k}`, k === 'mode' ? modosEnColor() : d])], { pie: `${t('tui.atajos')}\n${t('tui.atajos_raton')}` });
+    return bloqueDeTabla([['!', t('tip.bash')], ...COMANDOS.map(([k, d]) => [`/${k}`, k === 'mode' ? modosEnColor() : d])], { pie: `${t('tui.atajos')}\n${t('tui.atajos_arroba')}\n${t('tui.atajos_raton')}` });
 }
 async function cuentaOError(cred, pantalla) {
     try {
@@ -113,7 +140,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;
     }
@@ -126,14 +153,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() {
@@ -151,6 +177,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`);
@@ -161,7 +190,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) });
@@ -241,6 +270,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)
@@ -269,6 +300,8 @@ async function principal() {
     let control = new AbortController();
     let ocupado = false;
     let superficie = null;
+    let remoto = null;
+    let deFueraPendientes = 0;
     let bienvenida;
     let consejosDeEntrada = [];
     const confirmarNuevaEnMarcha = async () => {
@@ -282,15 +315,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)
@@ -306,6 +331,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 = () => {
@@ -347,6 +380,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)
@@ -355,10 +395,93 @@ async function principal() {
         finally {
             ocupado = false;
             superficie?.descansar();
+            remoto?.fijarEstado('libre', null);
         }
         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;
+            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'));
@@ -433,6 +556,25 @@ async function principal() {
         extra: sesion.ensenar ? 'Teach' : undefined,
         esperando: esperandoEnBandeja ?? 0,
     });
+    let conexionesAl = 0;
+    let conexionesViejas = true;
+    let sinConexiones = false;
+    const cargarConexiones = async () => {
+        if (sinConexiones)
+            return;
+        conexionesAl = Date.now();
+        conexionesViejas = false;
+        try {
+            const r = await leerConexiones(cred.servidor, cred.token);
+            superficie?.fijarConexiones(r.conexiones);
+        }
+        catch (e) {
+            if (e instanceof ErrorDeParallel && (e.codigo === 'sin_acceso' || e.codigo === 'sesion'))
+                sinConexiones = true;
+            else
+                conexionesViejas = true;
+        }
+    };
     if (interactiva) {
         superficie = new Superficie({
             entrada: process.stdin,
@@ -452,6 +594,17 @@ async function principal() {
                     avisarEnElEscritorio({ titulo: 'parx', texto: t('aviso.te_necesita', { pregunta: texto }) });
             },
             alNuevaEnMarcha: () => void confirmarNuevaEnMarcha(),
+            alArroba: () => {
+                if (conexionesViejas || Date.now() - conexionesAl > 60_000)
+                    void cargarConexiones();
+            },
+            alConectar: (x) => {
+                abrirNavegador(x.url);
+                registro.apuntar('conectar', { provider: x.provider });
+                pantalla.escribir(t('arroba.abriendo', { nombre: x.nombre, url: c.marca(x.url) }));
+                pantalla.escribir(c.gris(t('arroba.despues')));
+                conexionesViejas = true;
+            },
         });
         const s = superficie;
         process.on('exit', () => s.restaurarDeUrgencia());
@@ -476,15 +629,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;
@@ -504,6 +656,12 @@ async function principal() {
         const relojBandeja = setInterval(() => void mirarBandeja(), 90_000);
         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)
@@ -640,6 +798,147 @@ async function principal() {
             elegida = Math.min(elegida, lista.length - 1);
         }
     };
+    const pedir = async (texto, fn, errores = {}) => {
+        ocupado = true;
+        control = new AbortController();
+        superficie?.trabajar(() => control.abort());
+        pantalla.espera(texto, 'ruta', true);
+        try {
+            return await fn(control.signal);
+        }
+        catch (e) {
+            if (!(e instanceof ErrorDeParallel))
+                throw e;
+            const clave = errores[e.codigo === 'servidor' ? e.detalle.slice(0, 3) : e.codigo];
+            if (clave)
+                pantalla.aviso(t(clave));
+            else if (e.codigo !== 'interrumpido')
+                pantalla.error(mensajeDeError(e));
+            return null;
+        }
+        finally {
+            pantalla.pararEspera();
+            ocupado = false;
+            superficie?.descansar();
+        }
+    };
+    const notaDeMision = (m) => [t('misiones.progreso', { estado: m.texto || m.estado, n: m.progreso }), m.pendientes ? t('misiones.esperan', { n: m.pendientes }) : ''].filter(Boolean).join(sep());
+    const erroresDeMision = { sin_acceso: 'misiones.no_existe', '409': 'misiones.no_se_puede', '429': 'misiones.despacio' };
+    const unaMision = async (inicial) => {
+        let m = inicial;
+        let elegida = 0;
+        for (;;) {
+            const acciones = accionesDeUnaMision(m.estado);
+            const j = await superficie.elegir(m.titulo, [...acciones.map((a) => ({ etiqueta: a.etiqueta, nota: a.nota })), { etiqueta: t('misiones.volver') }], {
+                vertical: true,
+                detalle: notaDeMision(m),
+                elegida,
+            });
+            if (j === null)
+                return 'salir';
+            if (j >= acciones.length)
+                return 'volver';
+            elegida = j;
+            const a = acciones[j];
+            registro.apuntar('mision_accion', { accion: a.slug });
+            if (a.id === 'abrir') {
+                abrirNavegador(m.url);
+                pantalla.escribir(t('misiones.abierta', { url: c.marca(m.url) }));
+            }
+            else if (a.id === 'pausar' || a.id === 'reanudar') {
+                const accion = a.id;
+                const r = await pedir(t('misiones.mirando'), (s) => cicloDeMision(cred.servidor, cred.token, m.id, accion, s), erroresDeMision);
+                if (r) {
+                    pantalla.escribir(`${c.ok(SIMBOLOS.hecho)} ${t(accion === 'pausar' ? 'misiones.pausada' : 'misiones.reanudada', { titulo: m.titulo })}`);
+                    const otra = await leerMisiones(cred.servidor, cred.token).catch(() => null);
+                    m = otra?.misiones.find((x) => x.id === m.id) ?? { ...m, estado: r.estado };
+                    elegida = 0;
+                }
+            }
+            else if (a.id === 'compartir') {
+                const r = await pedir(t('misiones.mirando'), (s) => compartirMision(cred.servidor, cred.token, m.id, s), { ...erroresDeMision, '503': 'misiones.sin_compartir' });
+                if (r)
+                    pantalla.escribir(t(copiarAlPortapapeles(r.url) ? 'misiones.compartida' : 'misiones.compartida_sin_copiar', { url: c.marca(r.url) }));
+            }
+            else {
+                const r = await pedir(t('misiones.mirando'), (s) => leerMisionDeLaCuenta(cred.servidor, cred.token, m.id, s), erroresDeMision);
+                if (!r)
+                    continue;
+                const d = r.mision;
+                const titulo = `${a.id === 'resultado' ? t('misiones.resultado') : t('misiones.actividad')}${sep()}${d.titulo}`;
+                if (a.id === 'resultado') {
+                    const filas = [
+                        [t('misiones.meta'), d.objetivo ? t('misiones.objetivo', { etiqueta: d.objetivo.etiqueta, valor: d.objetivo.valor.toLocaleString('en-US'), meta: d.objetivo.meta.toLocaleString('en-US') }) : t('misiones.sin_objetivo')],
+                        [t('misiones.el_plan'), t('misiones.plan', { estado: d.texto || d.estado, n: d.progreso })],
+                    ];
+                    pantalla.bloque(bloqueDeTabla(filas, { titulo, pie: t('misiones.ver_resultados', { url: d.resultados }), sangria: 2 }));
+                }
+                else {
+                    pantalla.bloque(bloqueDeTabla(d.actividad.map((x) => [hace(x.cuando), x.texto]), { titulo, pie: d.actividad.length ? t('misiones.ver_actividad', { url: d.url }) : t('misiones.sin_actividad'), sangria: 2 }));
+                }
+            }
+        }
+    };
+    const misiones = async (filtro) => {
+        const leer = () => pedir(t('misiones.mirando'), (s) => leerMisiones(cred.servidor, cred.token, s), { sin_acceso: 'misiones.no_disponible', '429': 'misiones.despacio' });
+        let r = await leer();
+        if (!r)
+            return;
+        if (!r.misiones.length) {
+            pantalla.escribir(t('misiones.nada'));
+            return;
+        }
+        let lista = filtrarPorTitulo(r.misiones, filtro);
+        if (!lista.length) {
+            pantalla.escribir(t('misiones.sin_coincidencias', { q: filtro }));
+            return;
+        }
+        if (!superficie) {
+            for (const m of lista)
+                pantalla.escribir(`${m.titulo}${c.gris(`${sep()}${notaDeMision(m)}`)}  ${c.gris(m.url)}`);
+            return;
+        }
+        let elegida = 0;
+        for (;;) {
+            const i = await superficie.elegir(t('misiones.titulo'), lista.map((m) => ({ etiqueta: m.titulo, nota: notaDeMision(m) })), { vertical: true, elegida });
+            if (i === null)
+                return;
+            elegida = i;
+            if ((await unaMision(lista[i])) === 'salir')
+                return;
+            r = await leer();
+            if (!r)
+                return;
+            lista = filtrarPorTitulo(r.misiones, filtro);
+            if (!lista.length)
+                return;
+            elegida = Math.min(elegida, lista.length - 1);
+        }
+    };
+    const plantillas = async (filtro) => {
+        const r = await pedir(t('plantillas.mirando'), (s) => leerPlantillas(cred.servidor, cred.token, s), { sin_acceso: 'misiones.no_disponible', '429': 'misiones.despacio' });
+        if (!r)
+            return;
+        if (!r.plantillas.length) {
+            pantalla.escribir(t('plantillas.nada'));
+            return;
+        }
+        const lista = filtrarPorTitulo(r.plantillas, filtro);
+        if (!lista.length) {
+            pantalla.escribir(t('plantillas.sin_coincidencias', { q: filtro }));
+            return;
+        }
+        if (!superficie) {
+            for (const p of lista)
+                pantalla.escribir(`${p.titulo}${p.resumen ? c.gris(`${sep()}${p.resumen}`) : ''}`);
+            return;
+        }
+        const i = await superficie.elegir(t('plantillas.titulo'), lista.map((p) => ({ etiqueta: p.titulo, nota: p.propia ? t('plantillas.propia') : p.resumen })), { vertical: true });
+        if (i === null)
+            return;
+        superficie.ponerEnLaCaja(`/mission ${lista[i].objetivo.replace(/\s+/g, ' ').trim()}`);
+        pantalla.escribir(c.gris(t('plantillas.lista')));
+    };
     const bash = async (comando) => {
         if (!comando)
             return;
@@ -846,6 +1145,23 @@ async function principal() {
                     await bandeja();
                     superficie?.pintar();
                     break;
+                case 'missions':
+                    await misiones(resto);
+                    superficie?.pintar();
+                    break;
+                case 'templates':
+                    await plantillas(resto);
+                    superficie?.pintar();
+                    break;
+                case 'connections':
+                case 'settings': {
+                    const url = `${cred.servidor.replace(/\/$/, '')}/${cmd}`;
+                    abrirNavegador(url);
+                    if (cmd === 'connections')
+                        conexionesViejas = true;
+                    pantalla.escribir(t('ir.abriendo', { que: t(cmd === 'connections' ? 'ir.conexiones' : 'ir.ajustes'), url: c.marca(url) }));
+                    break;
+                }
                 case 'mouse': {
                     const si = ALIAS_SI_NO[arg] ?? (superficie?.conRaton ? 'no' : 'si');
                     guardarAjustes({ raton: si === 'si' });
@@ -863,6 +1179,33 @@ 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 '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'));
@@ -922,10 +1265,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/comandos.js

@@ -0,0 +1,71 @@
+export const DE_LA_WEB = {
+    plantillas: { slug: 'templates', parx: 'templates', como: 'nuevo', porque: 'Pick one and it is written as /mission <goal> in the input, to review and send.' },
+    adjuntar: { slug: 'attach', parx: null, como: 'no', porque: 'parx already reads the files of your project; images go in by dragging them into the window.' },
+    fuerza: { slug: 'strength', parx: 'model', como: 'alias', porque: 'In parx the strength is the model: Swift, Stride or Summit.' },
+    dictar: { slug: 'dictate', parx: null, como: 'no', porque: 'A terminal has no microphone of its own; the dictation of your system still types into it.' },
+    nueva: { slug: 'new', parx: 'new', como: 'choque', porque: 'parx keeps /new as a new conversation; a new mission is /mission.' },
+    misiones: { slug: 'missions', parx: 'missions', como: 'nuevo', porque: 'Your missions; pick one to open, pause or resume, share, see its result or its activity.' },
+    conexiones: { slug: 'connections', parx: 'connections', como: 'nuevo', porque: 'Opens your connections on getparallel.net.' },
+    ajustes: { slug: 'settings', parx: 'settings', como: 'nuevo', porque: 'Opens your settings on getparallel.net.' },
+    abrir: { slug: 'open', parx: null, como: 'en_misiones', porque: 'Inside /missions.' },
+    pausar: { slug: 'pause', parx: null, como: 'en_misiones', porque: 'Inside /missions, only for a running mission.' },
+    reanudar: { slug: 'resume', parx: null, como: 'en_misiones', porque: 'Inside /missions, only for a paused mission.' },
+    compartir: { slug: 'share', parx: null, como: 'en_misiones', porque: 'Inside /missions.' },
+    resultado: { slug: 'result', parx: null, como: 'en_misiones', porque: 'Inside /missions.' },
+    actividad: { slug: 'activity', parx: null, como: 'en_misiones', porque: 'Inside /missions.' },
+    ayuda: { slug: 'help', parx: 'help', como: 'ya', porque: 'parx already had /help.' },
+};
+export const ACCIONES_DE_MISION = [
+    { id: 'abrir', slug: 'open', etiqueta: 'Open', nota: 'In the browser' },
+    { id: 'pausar', slug: 'pause', etiqueta: 'Pause', nota: 'Stop the agents' },
+    { id: 'reanudar', slug: 'resume', etiqueta: 'Resume', nota: 'Pick up where it was' },
+    { id: 'compartir', slug: 'share', etiqueta: 'Share', nota: 'Read-only link, copied' },
+    { id: 'resultado', slug: 'result', etiqueta: 'Result', nota: 'How the goal is going' },
+    { id: 'actividad', slug: 'activity', etiqueta: 'Activity', nota: 'What the agents did' },
+];
+export function accionDeMisionPosible(id, estado) {
+    if (id === 'pausar')
+        return estado === 'active' || estado === 'at_risk';
+    if (id === 'reanudar')
+        return estado === 'paused';
+    return true;
+}
+export function accionesDeUnaMision(estado) {
+    return ACCIONES_DE_MISION.filter((a) => accionDeMisionPosible(a.id, estado));
+}
+export function normalizar(texto) {
+    return texto.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase();
+}
+export function filtrarPorTitulo(lista, consulta) {
+    const q = normalizar(consulta.trim());
+    if (!q)
+        return [...lista];
+    const puntuados = [];
+    lista.forEach((x, i) => {
+        const titulo = normalizar(x.titulo);
+        let p = -1;
+        if (titulo.startsWith(q))
+            p = 0;
+        else if (titulo.split(/[\s._-]+/).some((w) => w.startsWith(q)))
+            p = 1;
+        else if (titulo.includes(q))
+            p = 2;
+        if (p >= 0)
+            puntuados.push({ x, p, i });
+    });
+    return puntuados.sort((a, b) => a.p - b.p || a.i - b.i).map((v) => v.x);
+}
+export function hace(iso, ahora = Date.now()) {
+    const ms = ahora - new Date(iso).getTime();
+    if (!Number.isFinite(ms))
+        return '';
+    const min = Math.floor(ms / 60_000);
+    if (min < 1)
+        return 'just now';
+    if (min < 60)
+        return `${min}m ago`;
+    const h = Math.floor(min / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    return `${Math.floor(h / 24)}d ago`;
+}