@getparallel/parx 0.0.0-stage → 0.4.0

package/dist/cli.js

@@ -0,0 +1,700 @@
+#!/usr/bin/env node
+import { createInterface } from 'node:readline/promises';
+import { existsSync, statSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+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, fijarCapacidades, sep, signo } 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, leerCuenta, quienEs, verMision } from "./api.js";
+import { comoHasEntrado, credencialesActivas, entrar, formaDeLaOpcion, salir } from "./cuenta.js";
+import { hacerTarea, mensajeDeError, nuevaSesion } from "./agente.js";
+import { deshacerUltimo, permitirCarpeta } from "./herramientas.js";
+import { Registro } from "./registro.js";
+import { Pantalla } from "./ui.js";
+import { acciones, bloqueDeBienvenida, bloqueDeLaPersona, duracion, Superficie } from "./tui.js";
+import { CONSEJOS, cambiarConsejos, consejo, elegirConsejos, ordenDeConsejos } from "./consejos.js";
+import { anchoDe, recortarMedio } from "./texto.js";
+import { cargarImagen, ErrorDeImagen, extraerImagenes } from "./imagenes.js";
+import { avisarEnElEscritorio, debeAvisar } from "./notificar.js";
+import { copiarAlPortapapeles, escribirInforme } from "./informe.js";
+import { objetivoDeMision } from "./mision.js";
+import { ejecutarCarriles, MAX_CARRILES } from "./carriles.js";
+import { spawnSync } from 'node:child_process';
+import { comprobarDeFondo, esMasNueva, ordenDeActualizar, rutaDelCli, ultimaPublicada, versionNuevaConocida } from "./actualizar.js";
+function opciones() {
+    return parseArgs({
+        allowPositionals: true,
+        strict: false,
+        options: {
+            mode: { type: 'string' },
+            model: { type: 'string' },
+            modo: { type: 'string' },
+            modelo: { type: 'string' },
+            bypass: { type: 'boolean' },
+            sandbox: { type: 'boolean' },
+            'add-folder': { type: 'string', multiple: true },
+            lanes: { type: 'boolean' },
+            dir: { type: 'string', short: 'C' },
+            ascii: { type: 'boolean' },
+            version: { type: 'boolean', short: 'v' },
+            help: { type: 'boolean', short: 'h' },
+            browser: { type: 'boolean' },
+            web: { type: 'boolean' },
+            'api-key': { type: 'boolean' },
+            'with-api-key': { type: 'boolean' },
+            'no-browser': { type: 'boolean' },
+            'device-auth': { type: 'boolean' },
+            all: { type: 'boolean' },
+        },
+    });
+}
+function formaPedida(v) {
+    for (const k of ['browser', 'web', 'api-key', 'with-api-key', 'no-browser', 'device-auth']) {
+        if (v[k])
+            return formaDeLaOpcion(k);
+    }
+    return null;
+}
+function rutaCorta(ruta, max = 48) {
+    const casa = homedir();
+    const corta = ruta.startsWith(casa) ? `~${ruta.slice(casa.length)}` : ruta;
+    return recortarMedio(corta, max);
+}
+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];
+    for (const l of lineas)
+        process.stdout.write(`     ${l}\n`);
+    process.stdout.write('\n');
+}
+export function nombreDeModo(m) {
+    return t(`modo.${m}`);
+}
+export function modoDe(texto) {
+    const v = (texto ?? '').trim().toLowerCase();
+    const tabla = { ask: 'ask', preguntar: 'ask', auto: 'auto', read: 'read', 'read-only': 'read', readonly: 'read', leer: 'read', bypass: 'bypass' };
+    return tabla[v] ?? null;
+}
+export const SIGUIENTE_MODO = { ask: 'auto', auto: 'read', read: 'ask', bypass: 'ask' };
+function ayudaDeComandos() {
+    const ancho = Math.max(...COMANDOS.map(([k]) => anchoDe(k))) + 4;
+    const filas = COMANDOS.map(([k, d]) => `  ${c.marca(`/${k}`.padEnd(ancho))}${d}`);
+    return [...filas, '', c.gris(t('tui.atajos'))].join('\n');
+}
+async function cuentaOError(cred, pantalla) {
+    try {
+        return await leerCuenta(cred.servidor, cred.token);
+    }
+    catch (e) {
+        if (e instanceof ErrorDeParallel) {
+            pantalla.error(mensajeDeError(e));
+            return null;
+        }
+        throw e;
+    }
+}
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+async function actualizar() {
+    const { gestor, orden } = ordenDeActualizar(rutaDelCli());
+    if (gestor === 'npx') {
+        process.stdout.write(`${t('update.npx')}\n`);
+        return 0;
+    }
+    if (gestor === 'desarrollo' || !orden) {
+        process.stdout.write(`${t('update.desarrollo')}\n`);
+        return 0;
+    }
+    const ultima = await ultimaPublicada({ plazoMs: 8000 });
+    if (!ultima) {
+        process.stderr.write(`${t('update.sin_red')}\n`);
+        return 1;
+    }
+    if (!esMasNueva(ultima, VERSION)) {
+        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`);
+        return 1;
+    }
+    process.stdout.write(`${c.violeta('✓')} ${t('update.hecho')} (${VERSION} → ${ultima})\n`);
+    return 0;
+}
+async function principal() {
+    migrarCarpetaVieja();
+    const { values: v, positionals } = opciones();
+    const ajustes = leerAjustes();
+    if (v.ascii)
+        fijarCapacidades({ unicode: false });
+    if (/^(parallel-code|pcode)(\.js|\.cmd|\.ps1)?$/i.test(basename(process.argv[1] ?? '')))
+        process.stderr.write(`${c.gris(t('nombre.nuevo'))}\n`);
+    const claveDelEntorno = (process.env.PARALLEL_API_KEY ?? process.env.PARX_API_KEY ?? '').trim();
+    if (claveDelEntorno && !/^par_key_[A-Za-z0-9_-]{40}$/.test(claveDelEntorno))
+        process.stderr.write(`${c.aviso('!')} ${t('entrar.entorno_mal')}\n`);
+    if (v.version) {
+        process.stdout.write(`parx ${VERSION}\n`);
+        return 0;
+    }
+    if (v.help) {
+        cabeceraCorta();
+        process.stdout.write(`${USO}\n`);
+        return 0;
+    }
+    const pantalla = new Pantalla(null);
+    const primero = (positionals[0] ?? '').toLowerCase();
+    const solo = positionals.length === 1 && !v.lanes;
+    if (solo && ['update', 'upgrade'].includes(primero))
+        return actualizar();
+    void comprobarDeFondo();
+    if (solo && ['login', 'entrar', 'switch'].includes(primero)) {
+        cabeceraCorta();
+        await entrar((l) => pantalla.escribir(l), { forma: formaPedida(v) });
+        return 0;
+    }
+    if (solo && ['logout', 'salir'].includes(primero)) {
+        await salir((l) => pantalla.escribir(l), Boolean(v.all));
+        return 0;
+    }
+    if (solo && ['account', 'cuenta', 'whoami', 'status', 'balance'].includes(primero)) {
+        const cred = credencialesActivas();
+        if (!cred) {
+            pantalla.escribir(t('cuenta.sin_sesion'));
+            return 1;
+        }
+        const cu = await cuentaOError(cred, pantalla);
+        if (!cu)
+            return 1;
+        const filas = [
+            [t('cuenta.cuenta'), [cu.persona, correoVisible(cu.correo)].filter(Boolean).join(sep()) || '-'],
+            ...(cu.plan ? [[t('cuenta.plan'), cu.plan]] : []),
+            [t('cuenta.acciones'), t('cuenta.saldo', { n: (cu.disponibles ?? 0).toLocaleString('en-US') })],
+            [t('cuenta.entrada'), comoHasEntrado(cred, cu, hostname())],
+        ];
+        const ancho = Math.max(...filas.map(([a]) => a.length)) + 2;
+        pantalla.escribir();
+        for (const [a, b] of filas)
+            pantalla.escribir(`  ${c.gris(a.padEnd(ancho))}${b}`);
+        pantalla.escribir();
+        return 0;
+    }
+    const modoPedido = (v.mode ?? v.modo);
+    const pedido = modoDe(modoPedido);
+    if (pedido === 'bypass') {
+        process.stderr.write(`${c.aviso('!')} ${t('bypass.no_flag')}\n`);
+        return 2;
+    }
+    const quiereBypass = Boolean(v.bypass);
+    const modo = pedido ?? ajustes.modo ?? 'ask';
+    let modelo = modeloDe((v.model ?? v.modelo)) ?? ajustes.modelo ?? MODELO_POR_DEFECTO;
+    const raiz = resolve(v.dir ?? process.cwd());
+    if (!existsSync(raiz) || !statSync(raiz).isDirectory()) {
+        pantalla.error(`${raiz}?`);
+        return 1;
+    }
+    let cred = credencialesActivas();
+    if (!cred) {
+        if (!pantalla.tty) {
+            pantalla.escribir(t('cuenta.sin_sesion'));
+            return 1;
+        }
+        cabeceraCorta();
+        cred = await entrar((l) => pantalla.escribir(l));
+    }
+    const cuenta = await cuentaOError(cred, pantalla);
+    if (!cuenta)
+        return 1;
+    const registro = new Registro(randomUUID());
+    const conCarriles = Boolean(v.lanes);
+    const tarea = conCarriles ? '' : positionals.join(' ').trim();
+    const tareasDeCarriles = conCarriles ? positionals.map((p) => p.trim()).filter(Boolean) : [];
+    if (tareasDeCarriles.length > MAX_CARRILES) {
+        pantalla.error(t('carriles.max'));
+        return 2;
+    }
+    const interactiva = pantalla.tty && !tarea && !(conCarriles && !pantalla.tty);
+    const rl = pantalla.tty && !interactiva ? createInterface({ input: process.stdin, output: process.stdout, terminal: true, historySize: 200 }) : null;
+    pantalla.fijarLectora(rl);
+    const sesion = nuevaSesion(cred.servidor, cred.token, modelo, {
+        raiz,
+        modo,
+        pantalla,
+        registro,
+        permitidos: new Set(),
+        deshacer: [],
+        carpetas: [],
+        lecturas: [],
+        jaula: Boolean(v.sandbox),
+    });
+    for (const f of v['add-folder'] ?? []) {
+        const ok = permitirCarpeta(sesion.ctx, f);
+        if (!ok)
+            pantalla.error(t('carpeta.no_existe', { ruta: f }));
+    }
+    registro.apuntar('inicio', { version: VERSION, raiz, modo, modelo, carpetas: sesion.ctx.carpetas?.length ?? 0, jaula: Boolean(v.sandbox), plataforma: process.platform, interactiva: !tarea });
+    const confirmarBypass = async () => {
+        const r = await pantalla.preguntar(t('bypass.confirmar'), { tipo: 'bypass' });
+        if (r !== 'si') {
+            pantalla.escribir(c.gris(t('bypass.cancelado', { modo: nombreDeModo(sesion.ctx.modo) })));
+            return false;
+        }
+        sesion.ctx.modo = 'bypass';
+        sesion.ctx.permitidos.clear();
+        registro.apuntar('modo', { modo: 'bypass' });
+        return true;
+    };
+    let disponibles = cuenta.disponibles;
+    const saldo = () => (disponibles == null ? '' : t('cuenta.saldo', { n: disponibles.toLocaleString('en-US') }));
+    const saldoCorto = () => (disponibles == null ? '' : disponibles.toLocaleString('en-US'));
+    const quien = quienEs(cuenta);
+    let avisos = ajustes.avisos !== false;
+    let control = new AbortController();
+    let ocupado = false;
+    let superficie = null;
+    let ctrlC = 0;
+    const totalDeLaSesion = () => sesion.total.tareas ? c.gris(t('estado.total', { acciones: acciones(sesion.total.acciones), tiempo: duracion(sesion.total.ms) })) : '';
+    const despedida = () => [totalDeLaSesion(), c.gris(t('repl.adios'))].filter(Boolean).join('\n  ');
+    const adios = () => {
+        if (superficie)
+            superficie.terminar(despedida());
+        else
+            pantalla.escribir(despedida());
+        process.exit(0);
+    };
+    const alCtrlC = () => {
+        ctrlC++;
+        if (ctrlC >= 2)
+            adios();
+    };
+    process.on('SIGINT', () => {
+        if (ocupado)
+            control.abort();
+        else
+            alCtrlC();
+    });
+    rl?.on('SIGINT', () => (ocupado ? control.abort() : alCtrlC()));
+    const quizaAvisar = (texto, ms) => {
+        if (!avisos)
+            return;
+        if (debeAvisar(superficie ? superficie.enfocada : null, ms))
+            avisarEnElEscritorio({ titulo: 'parx', texto });
+    };
+    const imagenesDe = (linea) => {
+        const { texto, rutas } = extraerImagenes(linea, raiz);
+        const imagenes = [];
+        for (const r of rutas) {
+            try {
+                imagenes.push(cargarImagen(r));
+            }
+            catch (e) {
+                const m = e instanceof ErrorDeImagen ? e.message : '';
+                pantalla.error(m.startsWith('grande:') ? t('imagen.grande', { mb: m.slice(7), max: '2.5' }) : t('imagen.no_se_lee', { ruta: rutaCorta(r) }));
+            }
+        }
+        return { texto, imagenes };
+    };
+    const hacer = async (linea) => {
+        const { texto, imagenes } = imagenesDe(linea);
+        ocupado = true;
+        control = new AbortController();
+        superficie?.trabajar(() => control.abort());
+        const inicio = Date.now();
+        let seguir = true;
+        try {
+            seguir = await hacerTarea(sesion, texto, control.signal, imagenes);
+            if (sesion.disponibles !== undefined && sesion.disponibles !== null)
+                disponibles = sesion.disponibles;
+        }
+        finally {
+            ocupado = false;
+            superficie?.descansar();
+        }
+        quizaAvisar(t('aviso.termino', { tarea: texto.replace(/\s+/g, ' ').slice(0, 80) }), Date.now() - inicio);
+        return seguir;
+    };
+    const carriles = async (tareas) => {
+        if (tareas.length < 2) {
+            pantalla.escribir(t('carriles.min'));
+            return true;
+        }
+        ocupado = true;
+        control = new AbortController();
+        pantalla.escribir(c.gris(t('carriles.empieza', { n: tareas.length })));
+        const inicio = Date.now();
+        if (superficie)
+            superficie.trabajar(() => control.abort());
+        let r;
+        try {
+            r = await ejecutarCarriles({
+                tareas,
+                servidor: cred.servidor,
+                token: cred.token,
+                modelo: sesion.modelo,
+                base: sesion.ctx,
+                superficie,
+                lectora: rl,
+                tty: pantalla.tty,
+                ensenar: sesion.ensenar,
+                señal: control.signal,
+            });
+        }
+        finally {
+            ocupado = false;
+            superficie?.descansar();
+        }
+        superficie?.fijarCarriles([]);
+        let gastadas = 0;
+        r.sesiones.forEach((s, i) => {
+            for (const d of s.diario)
+                sesion.diario.push({ ...d, pedido: tareas[i] ?? d.pedido });
+            sesion.total.acciones += s.total.acciones;
+            sesion.total.tareas += s.total.tareas;
+            gastadas += s.total.acciones;
+            if (s.disponibles != null)
+                disponibles = Math.min(disponibles ?? Infinity, s.disponibles);
+        });
+        const ms = Date.now() - inicio;
+        sesion.total.ms += ms;
+        pantalla.cierre(`${t('carriles.hecho', { n: tareas.length })}${c.gris(sep())}${c.gris(acciones(gastadas))}${c.gris(sep())}${c.gris(duracion(ms))}`);
+        quizaAvisar(t('carriles.hecho', { n: tareas.length }), ms);
+        return r.ok;
+    };
+    if (tarea) {
+        cabeceraCorta([c.gris([nombreDeModo(modo), nombreDeModelo(modelo), cuenta.plan, rutaCorta(raiz)].filter(Boolean).join(sep()))]);
+        if (quiereBypass && (await confirmarBypass()))
+            pantalla.aviso(t('bypass.flag'));
+        pantalla.bloque(bloqueDeLaPersona(tarea));
+        const ok = await hacer(tarea);
+        rl?.close();
+        return ok ? 0 : 1;
+    }
+    if (conCarriles && !interactiva) {
+        cabeceraCorta([c.gris([nombreDeModo(modo), nombreDeModelo(modelo), rutaCorta(raiz)].join(sep()))]);
+        if (quiereBypass && (await confirmarBypass()))
+            pantalla.aviso(t('bypass.flag'));
+        const ok = await carriles(tareasDeCarriles);
+        rl?.close();
+        return ok ? 0 : 1;
+    }
+    const estado = () => ({
+        modo: nombreDeModo(sesion.ctx.modo),
+        modelo: nombreDeModelo(sesion.modelo),
+        saldo: saldo(),
+        saldoCorto: saldoCorto(),
+        peligro: sesion.ctx.modo === 'bypass',
+        extra: sesion.ensenar ? 'Teach' : undefined,
+    });
+    if (interactiva) {
+        superficie = new Superficie({
+            entrada: process.stdin,
+            salida: process.stdout,
+            estado,
+            alCambiarModo: () => {
+                sesion.ctx.modo = SIGUIENTE_MODO[sesion.ctx.modo];
+                sesion.ctx.permitidos.clear();
+                if (sesion.ctx.modo !== 'bypass')
+                    guardarAjustes({ modo: sesion.ctx.modo });
+            },
+            alSalir: adios,
+            alPreguntar: (texto) => {
+                if (avisos && superficie?.enfocada === false)
+                    avisarEnElEscritorio({ titulo: 'parx', texto: t('aviso.te_necesita', { pregunta: texto }) });
+            },
+        });
+        const s = superficie;
+        process.on('exit', () => s.restaurarDeUrgencia());
+        pantalla.fijarSuperficie(superficie);
+        const elegidos = elegirConsejos(leerAjustes().consejos);
+        if (elegidos.ids.length)
+            guardarAjustes({ consejos: elegidos.estado });
+        superficie.iniciar(bloqueDeBienvenida({
+            version: VERSION,
+            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;
+            })(),
+            peligro: () => sesion.ctx.modo === 'bypass',
+        }), conCarriles || quiereBypass ? [] : elegidos.ids);
+        if (quiereBypass)
+            await confirmarBypass();
+    }
+    const leerLinea = async (ejemplo = null) => {
+        if (superficie)
+            return superficie.leer(ejemplo);
+        try {
+            return await rl.question(`${c.claro(signo())} `);
+        }
+        catch {
+            return null;
+        }
+    };
+    if (conCarriles) {
+        const ok = await carriles(tareasDeCarriles.length >= 2 ? tareasDeCarriles : await pedirCarriles());
+        if (!ok) {
+            superficie?.terminar(despedida());
+            return 1;
+        }
+    }
+    async function pedirCarriles() {
+        pantalla.escribir(c.gris(t('carriles.cuantas')));
+        const tareas = [];
+        while (tareas.length < MAX_CARRILES) {
+            const l = await leerLinea(t('tui.escribe_carril', { n: tareas.length + 1 }));
+            if (l === null || !l.trim())
+                break;
+            tareas.push(l.trim());
+        }
+        return tareas;
+    }
+    for (;;) {
+        const r = await leerLinea();
+        if (r === null)
+            break;
+        const linea = r.trim();
+        ctrlC = 0;
+        if (!linea)
+            continue;
+        if (linea.startsWith('/')) {
+            const [nombre = '', ...args] = linea.slice(1).split(/\s+/);
+            const cmd = ALIAS_COMANDO[nombre.toLowerCase()];
+            const resto = linea.slice(1 + nombre.length).trim();
+            const arg = (args[0] ?? '').toLowerCase();
+            switch (cmd) {
+                case 'exit':
+                    if (superficie)
+                        superficie.terminar(despedida());
+                    else
+                        pantalla.escribir(despedida());
+                    rl?.close();
+                    return 0;
+                case 'help':
+                    pantalla.escribir(ayudaDeComandos());
+                    break;
+                case 'mode': {
+                    const m = modoDe(arg);
+                    if (m === 'bypass') {
+                        if (sesion.ctx.modo === 'bypass')
+                            break;
+                        if ((await confirmarBypass()) && !superficie)
+                            pantalla.aviso(t('bypass.on'));
+                        superficie?.pintar();
+                        break;
+                    }
+                    if (m) {
+                        sesion.ctx.modo = m;
+                        sesion.ctx.permitidos.clear();
+                        guardarAjustes({ modo: m });
+                        registro.apuntar('modo', { modo: m });
+                    }
+                    pantalla.escribir(t('modo.ahora', { modo: nombreDeModo(sesion.ctx.modo), desc: t(`modo.${sesion.ctx.modo}.desc`) }));
+                    superficie?.pintar();
+                    break;
+                }
+                case 'model': {
+                    const m = modeloDe(resto);
+                    if (m) {
+                        modelo = m;
+                        sesion.modelo = m;
+                        guardarAjustes({ modelo: m });
+                    }
+                    pantalla.escribir(t('modelo.ahora', { modelo: nombreDeModelo(sesion.modelo), desc: MODELOS[sesion.modelo].descripcion }));
+                    superficie?.pintar();
+                    break;
+                }
+                case 'folder': {
+                    if (!resto) {
+                        const lista = sesion.ctx.carpetas ?? [];
+                        pantalla.escribir(lista.length ? t('carpeta.lista', { lista: lista.map((x) => rutaCorta(x, 60)).join(', ') }) : t('carpeta.ninguna'));
+                        break;
+                    }
+                    const ruta = resto.replace(/^['"]|['"]$/g, '').replace(/\\(.)/g, '$1');
+                    const ok = permitirCarpeta(sesion.ctx, ruta);
+                    registro.apuntar('carpeta', { ok: Boolean(ok) });
+                    pantalla.escribir(ok ? t('carpeta.ok', { ruta: rutaCorta(ok, 60) }) : t('carpeta.no_existe', { ruta }));
+                    break;
+                }
+                case 'lanes': {
+                    const seguir = await carriles(await pedirCarriles());
+                    if (!seguir) {
+                        superficie?.terminar(despedida());
+                        rl?.close();
+                        return 1;
+                    }
+                    break;
+                }
+                case 'teach': {
+                    const si = ALIAS_SI_NO[arg] ?? (sesion.ensenar ? 'no' : 'si');
+                    sesion.ensenar = si === 'si';
+                    pantalla.escribir(sesion.ensenar ? t('repl.ensenar_on') : t('repl.ensenar_off'));
+                    superficie?.pintar();
+                    break;
+                }
+                case 'report': {
+                    if (!sesion.diario.length) {
+                        pantalla.escribir(t('informe.nada'));
+                        break;
+                    }
+                    ocupado = true;
+                    control = new AbortController();
+                    superficie?.trabajar(() => control.abort());
+                    pantalla.espera(t('hace.informe'), 'tendido', true);
+                    try {
+                        const inf = await escribirInforme(cred.servidor, cred.token, sesion.id, sesion.diario, basename(raiz), control.signal);
+                        pantalla.pararEspera();
+                        if (inf.disponibles != null)
+                            disponibles = inf.disponibles;
+                        sesion.total.acciones += inf.acciones;
+                        pantalla.escribir();
+                        pantalla.texto(`**${t('informe.titulo')}**\n\n${inf.texto}`);
+                        pantalla.escribir();
+                        pantalla.cierre(`${copiarAlPortapapeles(inf.texto) ? t('informe.copiado') : t('informe.titulo')}${c.gris(sep())}${c.gris(acciones(inf.acciones))}`);
+                    }
+                    catch (e) {
+                        pantalla.pararEspera();
+                        if (e instanceof ErrorDeParallel) {
+                            if (e.codigo !== 'interrumpido')
+                                pantalla.error(mensajeDeError(e));
+                        }
+                        else
+                            throw e;
+                    }
+                    finally {
+                        ocupado = false;
+                        superficie?.descansar();
+                    }
+                    break;
+                }
+                case 'mission': {
+                    const objetivo = objetivoDeMision(resto, sesion.diario);
+                    if (!objetivo) {
+                        pantalla.escribir(t('mision.nada'));
+                        break;
+                    }
+                    pantalla.escribir(c.gris(t('mision.explica')));
+                    ocupado = true;
+                    control = new AbortController();
+                    superficie?.trabajar(() => control.abort());
+                    pantalla.espera(t('hace.mision'), 'ruta', true);
+                    try {
+                        const m = await crearMision(cred.servidor, cred.token, objetivo, control.signal);
+                        registro.apuntar('mision', { generacion: m.generacion });
+                        pantalla.pararEspera();
+                        pantalla.escribir(t('mision.creada', { url: c.marca(m.url) }));
+                        pantalla.escribir(c.gris(t('mision.plan')));
+                        let vista = m;
+                        for (let i = 0; i < 20 && !control.signal.aborted && vista.estado !== 'launched' && vista.estado !== 'failed'; i++) {
+                            await dormir(3000);
+                            try {
+                                vista = await verMision(cred.servidor, cred.token, m.generacion, control.signal);
+                            }
+                            catch {
+                                break;
+                            }
+                        }
+                        if (vista.estado === 'launched')
+                            pantalla.cierre(t('mision.lanzada'));
+                        else if (vista.estado === 'failed')
+                            pantalla.error(t('mision.no_disponible'));
+                    }
+                    catch (e) {
+                        pantalla.pararEspera();
+                        if (e instanceof ErrorDeParallel) {
+                            if (e.codigo === 'sin_saldo')
+                                pantalla.error(t('mision.limite'));
+                            else if (e.detalle === 'mantenimiento')
+                                pantalla.error(t('mision.cerradas'));
+                            else if (e.codigo !== 'interrumpido')
+                                pantalla.error(mensajeDeError(e));
+                        }
+                        else
+                            throw e;
+                    }
+                    finally {
+                        ocupado = false;
+                        superficie?.descansar();
+                    }
+                    break;
+                }
+                case 'new':
+                    sesion.conversacion = [];
+                    pantalla.escribir(t('repl.nueva'));
+                    break;
+                case 'undo': {
+                    const r2 = deshacerUltimo(sesion.ctx);
+                    pantalla.escribir(r2 ? t('repl.deshecho', { ruta: r2 }) : t('repl.nada_que_deshacer'));
+                    if (r2)
+                        sesion.conversacion.push({ role: 'user', content: `(The user undid your last change to ${r2}. It is back to how it was before.)` });
+                    break;
+                }
+                case 'balance': {
+                    const cu = await cuentaOError(cred, pantalla);
+                    if (cu) {
+                        disponibles = cu.disponibles;
+                        const yo = quienEs(cu);
+                        const n = (cu.disponibles ?? 0).toLocaleString('en-US');
+                        pantalla.escribir(yo ? t('cuenta.quien', { correo: yo, n }) : t('cuenta.saldo', { n }));
+                        superficie?.pintar();
+                    }
+                    break;
+                }
+                case 'notify': {
+                    const si = ALIAS_SI_NO[arg] ?? (avisos ? 'no' : 'si');
+                    avisos = si === 'si';
+                    guardarAjustes({ avisos });
+                    pantalla.escribir(avisos ? t('repl.avisos_on') : t('repl.avisos_off'));
+                    break;
+                }
+                case 'log':
+                    pantalla.escribir(t('repl.registro', { ruta: registro.ruta }));
+                    break;
+                case 'tips': {
+                    const si = ALIAS_SI_NO[arg];
+                    if (si) {
+                        guardarAjustes({ consejos: cambiarConsejos(leerAjustes().consejos, si === 'si') });
+                        pantalla.escribir(si === 'si' ? t('consejos.encendidos') : t('consejos.apagados', { orden: ordenDeConsejos(true) }));
+                    }
+                    else {
+                        const todos = CONSEJOS.map((id) => consejo(id));
+                        const ancho = Math.max(...todos.map((k) => anchoDe(k.tecla))) + 3;
+                        const filas = todos.map((k) => `  ${c.marca(k.tecla + ' '.repeat(Math.max(0, ancho - anchoDe(k.tecla))))}${k.texto}`);
+                        const apagados = leerAjustes().consejos?.apagados;
+                        const pie = apagados ? t('consejos.apagados', { orden: ordenDeConsejos(true) }) : t('consejos.quitar', { orden: ordenDeConsejos(false) });
+                        pantalla.escribir([c.negrita(t('consejos.titulo')), ...filas, '', c.gris(pie)].join('\n'));
+                    }
+                    break;
+                }
+                default:
+                    pantalla.escribir(t('repl.desconocido'));
+            }
+            continue;
+        }
+        const seguir = await hacer(linea);
+        if (!seguir) {
+            superficie?.terminar(despedida());
+            rl?.close();
+            return 1;
+        }
+    }
+    superficie?.terminar(despedida());
+    rl?.close();
+    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);
+    });
+}