@getparallel/parx 0.5.0 → 0.6.0

package/dist/remoto.js

@@ -0,0 +1,284 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { abrirRemoto, cerrarRemoto, ErrorDeParallel, latidoRemoto, ordenesRemotas } from "./api.js";
+import { sinColor } from "./marca.js";
+export function seContestaDesdeFuera(clase) {
+    return clase !== 'credencial' && clase !== 'bypass';
+}
+const SECRETOS = [
+    /\b(sk|pk|rk)[-_](live|test|proj|ant)?[-_]?[A-Za-z0-9_-]{16,}/g,
+    /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+    /\bxox[abprs]-[A-Za-z0-9-]{10,}/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bAIza[0-9A-Za-z_-]{30,}/g,
+    /\bpar_(term|key)_[A-Za-z0-9_-]{8,}/g,
+    /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+];
+const CON_NOMBRE = [/\b(Bearer\s+)[A-Za-z0-9._~+/-]{16,}=*/gi, /\b((?:password|passwd|secret|token|api[_-]?key)\s*[:=]\s*['"]?)[^\s'"]{6,}/gi];
+export function taparSecretos(s) {
+    let r = s;
+    for (const re of CON_NOMBRE)
+        r = r.replace(re, (_m, nombre) => `${nombre}[hidden]`);
+    for (const re of SECRETOS)
+        r = r.replace(re, '[hidden]');
+    return r;
+}
+const MAX_TEXTO = 8000;
+export function paraElMovil(v, max = MAX_TEXTO) {
+    const s = taparSecretos(sinColor(typeof v === 'string' ? v : v == null ? '' : String(v)));
+    return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+function limpiar(datos) {
+    const out = {};
+    for (const [k, v] of Object.entries(datos)) {
+        if (typeof v === 'string')
+            out[k] = paraElMovil(v);
+        else if (Array.isArray(v))
+            out[k] = v.slice(0, 60).map((x) => (typeof x === 'string' ? paraElMovil(x, 400) : x && typeof x === 'object' ? limpiar(x) : x));
+        else if (v && typeof v === 'object')
+            out[k] = limpiar(v);
+        else
+            out[k] = v;
+    }
+    return out;
+}
+const API = { abrir: abrirRemoto, latido: latidoRemoto, ordenes: ordenesRemotas, cerrar: cerrarRemoto };
+let contadorDePreguntas = 0;
+export class Remoto {
+    id = null;
+    url = null;
+    o;
+    api;
+    n = 0;
+    cola = [];
+    estado = 'libre';
+    tarea = null;
+    acciones = 0;
+    modo = '';
+    modelo = '';
+    activo = false;
+    enviando = false;
+    otraVez = false;
+    relojEnvio = null;
+    relojLatido = null;
+    escucha = null;
+    ultimoEnvio = 0;
+    preguntas = new Map();
+    constructor(o) {
+        this.o = o;
+        this.api = { ...API, ...o.api };
+    }
+    get encendido() {
+        return this.activo;
+    }
+    async abrir(datos) {
+        const r = await this.api.abrir(this.o.servidor, this.o.token, datos);
+        this.id = r.id;
+        this.url = r.url;
+        this.modo = datos.modo;
+        this.modelo = datos.modelo;
+        this.activo = true;
+        this.relojLatido = setInterval(() => void this.enviar(), this.o.latidoMs ?? 15_000);
+        this.relojLatido.unref?.();
+        void this.enviar();
+        void this.escuchar();
+        return r;
+    }
+    async cerrar() {
+        if (!this.activo)
+            return;
+        this.apagar();
+        if (this.id) {
+            try {
+                await this.api.cerrar(this.o.servidor, this.o.token, this.id);
+            }
+            catch {
+            }
+        }
+    }
+    apagar() {
+        this.activo = false;
+        if (this.carpeta && !this.o.carpetaDeFotos)
+            rmSync(this.carpeta, { recursive: true, force: true });
+        if (this.relojEnvio)
+            clearTimeout(this.relojEnvio);
+        if (this.relojLatido)
+            clearInterval(this.relojLatido);
+        this.relojEnvio = this.relojLatido = null;
+        this.escucha?.abort();
+        this.escucha = null;
+        this.preguntas.clear();
+    }
+    evento(tipo, datos) {
+        if (!this.activo)
+            return;
+        this.cola.push({ n: this.n++, tipo, datos: limpiar(datos) });
+        if (!this.relojEnvio) {
+            this.relojEnvio = setTimeout(() => {
+                this.relojEnvio = null;
+                void this.enviar();
+            }, this.o.cadaMs ?? 400);
+            this.relojEnvio.unref?.();
+        }
+    }
+    fijarEstado(estado, tarea) {
+        if (!this.activo)
+            return;
+        const cambia = estado !== this.estado || (tarea !== undefined && tarea !== this.tarea);
+        this.estado = estado;
+        if (tarea !== undefined)
+            this.tarea = tarea ? paraElMovil(tarea, 200) : null;
+        if (cambia)
+            void this.enviar();
+    }
+    fijarModo(modo, modelo) {
+        this.modo = modo;
+        this.modelo = modelo;
+    }
+    progreso(acciones) {
+        this.acciones = acciones;
+    }
+    preguntaRemota(texto, clase, opciones) {
+        const id = `p${Date.now().toString(36)}${(contadorDePreguntas++).toString(36)}`;
+        const fuera = seContestaDesdeFuera(clase);
+        let deFuera = null;
+        const valores = opciones.map((x) => x.valor);
+        if (this.activo && fuera)
+            deFuera = new Promise((resolver) => this.preguntas.set(id, { resolver, valores }));
+        const anterior = this.estado;
+        this.evento('pregunta', { id, texto, clase, opciones: opciones.map((x) => ({ etiqueta: x.etiqueta, valor: x.valor })), remota: fuera });
+        this.fijarEstado('pregunta');
+        return {
+            id,
+            deFuera,
+            contestada: (valor, desde) => {
+                this.preguntas.delete(id);
+                this.evento('respuesta', { id, valor, desde });
+                this.fijarEstado(anterior === 'pregunta' ? 'trabajando' : anterior);
+            },
+        };
+    }
+    async enviar() {
+        if (!this.activo || !this.id)
+            return;
+        if (this.enviando) {
+            this.otraVez = true;
+            return;
+        }
+        this.enviando = true;
+        try {
+            const tanda = this.cola.slice(0, 200);
+            const r = await this.api.latido(this.o.servidor, this.o.token, this.id, {
+                estado: this.estado,
+                tarea: this.tarea,
+                acciones: this.acciones,
+                modo: this.modo,
+                modelo: this.modelo,
+                eventos: tanda,
+            });
+            this.cola.splice(0, tanda.length);
+            this.ultimoEnvio = Date.now();
+            if (r.cerrado) {
+                this.apagar();
+                this.o.alApagarse('web');
+                return;
+            }
+        }
+        catch (e) {
+            if (this.cola.length > 2000)
+                this.cola.splice(0, this.cola.length - 2000);
+            if (e instanceof ErrorDeParallel && (e.codigo === 'sesion' || e.codigo === 'sin_acceso')) {
+                this.apagar();
+                this.o.alApagarse(e.codigo);
+                return;
+            }
+        }
+        finally {
+            this.enviando = false;
+        }
+        if (this.otraVez || (this.cola.length && !this.relojEnvio)) {
+            this.otraVez = false;
+            void this.enviar();
+        }
+    }
+    async escuchar() {
+        let pausa = 1000;
+        while (this.activo && this.id) {
+            this.escucha = new AbortController();
+            try {
+                const r = await this.api.ordenes(this.o.servidor, this.o.token, this.id, this.o.esperaMs ?? 25_000, this.escucha.signal);
+                pausa = 1000;
+                if (r.cerrado) {
+                    this.apagar();
+                    this.o.alApagarse('web');
+                    return;
+                }
+                for (const orden of r.ordenes)
+                    this.cumplir(orden);
+            }
+            catch (e) {
+                if (!this.activo)
+                    return;
+                if (e instanceof ErrorDeParallel && (e.codigo === 'sesion' || e.codigo === 'sin_acceso')) {
+                    this.apagar();
+                    this.o.alApagarse(e.codigo);
+                    return;
+                }
+                await new Promise((r) => setTimeout(r, pausa).unref?.());
+                pausa = Math.min(30_000, pausa * 2);
+            }
+        }
+    }
+    cumplir(orden) {
+        if (!this.activo)
+            return;
+        if (orden.tipo === 'mensaje') {
+            const texto = typeof orden.datos.texto === 'string' ? orden.datos.texto.trim().slice(0, MAX_TEXTO) : '';
+            const rutas = this.guardarFotos(orden);
+            const conFotos = [texto || (rutas.length ? 'Look at this photo.' : ''), ...rutas.map((r) => `"${r}"`)].filter(Boolean).join(' ');
+            if (conFotos)
+                this.o.alMensaje(conFotos);
+            return;
+        }
+        if (orden.tipo === 'parar') {
+            this.o.alParar();
+            return;
+        }
+        if (orden.tipo === 'respuesta') {
+            const id = String(orden.datos.pregunta ?? '');
+            const valor = orden.datos.valor;
+            const p = this.preguntas.get(id);
+            if (!p || (valor !== 'si' && valor !== 'siempre' && valor !== 'no') || !p.valores.includes(valor))
+                return;
+            this.preguntas.delete(id);
+            p.resolver(valor);
+        }
+    }
+    carpeta = null;
+    guardarFotos(orden) {
+        const fotos = Array.isArray(orden.datos.fotos) ? orden.datos.fotos.slice(0, 3) : [];
+        const rutas = [];
+        fotos.forEach((f, i) => {
+            const ext = f.mime === 'image/png' ? 'png' : f.mime === 'image/webp' ? 'webp' : f.mime === 'image/jpeg' ? 'jpg' : null;
+            if (!ext || typeof f.datos !== 'string' || !/^[A-Za-z0-9+/]+={0,2}$/.test(f.datos))
+                return;
+            const buf = Buffer.from(f.datos, 'base64');
+            if (buf.length < 16 || buf.length > 2_500_000)
+                return;
+            try {
+                this.carpeta ??= this.o.carpetaDeFotos ?? join(tmpdir(), `parx-remoto-${process.pid}`);
+                mkdirSync(this.carpeta, { recursive: true, mode: 0o700 });
+                const ruta = join(this.carpeta, `photo-${orden.id.replace(/[^a-z0-9-]/gi, '').slice(0, 12)}-${i + 1}.${ext}`);
+                writeFileSync(ruta, buf, { mode: 0o600 });
+                rutas.push(ruta);
+            }
+            catch {
+            }
+        });
+        return rutas;
+    }
+    get msDesdeElUltimoEnvio() {
+        return this.ultimoEnvio ? Date.now() - this.ultimoEnvio : Number.POSITIVE_INFINITY;
+    }
+}

package/dist/tar.js

@@ -0,0 +1,99 @@
+import { gunzipSync } from 'node:zlib';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, join, normalize, sep } from 'node:path';
+const BLOQUE = 512;
+function campo(b, desde, largo) {
+    const fin = b.indexOf(0, desde);
+    return b.subarray(desde, fin === -1 || fin > desde + largo ? desde + largo : fin).toString('utf8');
+}
+function numero(b, desde, largo) {
+    const s = campo(b, desde, largo).trim();
+    if (!s)
+        return 0;
+    if (b[desde] & 0x80) {
+        let n = 0;
+        for (let i = 1; i < largo; i++)
+            n = n * 256 + b[desde + i];
+        return n;
+    }
+    const n = parseInt(s, 8);
+    return Number.isFinite(n) ? n : 0;
+}
+export function leerTar(tar, limites = {}) {
+    const maxFicheros = limites.maxFicheros ?? 400;
+    const maxBytes = limites.maxBytes ?? 20 * 1024 * 1024;
+    const prefijo = limites.prefijo ?? 'package/';
+    const salida = [];
+    let bytes = 0;
+    let pos = 0;
+    let nombreLargo = null;
+    let rutaPax = null;
+    while (pos + BLOQUE <= tar.length) {
+        const cab = tar.subarray(pos, pos + BLOQUE);
+        if (cab.every((x) => x === 0))
+            break;
+        const tipo = String.fromCharCode(cab[156]);
+        const tamano = numero(cab, 124, 12);
+        const datos = tar.subarray(pos + BLOQUE, pos + BLOQUE + tamano);
+        pos += BLOQUE + Math.ceil(tamano / BLOQUE) * BLOQUE;
+        if (tipo === 'L') {
+            nombreLargo = datos.toString('utf8').replace(/\0+$/, '');
+            continue;
+        }
+        if (tipo === 'x') {
+            for (const linea of datos.toString('utf8').split('\n')) {
+                const m = /^\d+ path=(.*)$/.exec(linea);
+                if (m)
+                    rutaPax = m[1];
+            }
+            continue;
+        }
+        if (tipo === 'g')
+            continue;
+        let nombre = rutaPax ?? nombreLargo ?? campo(cab, 0, 100);
+        if (!rutaPax && !nombreLargo && campo(cab, 257, 6) === 'ustar') {
+            const pre = campo(cab, 345, 155);
+            if (pre)
+                nombre = `${pre}/${nombre}`;
+        }
+        rutaPax = null;
+        nombreLargo = null;
+        if (tipo === '5' || nombre.endsWith('/'))
+            continue;
+        if (tipo !== '0' && tipo !== '\0' && tipo !== '7')
+            throw new Error(`unsupported entry type "${tipo}" for ${nombre}`);
+        if (!nombre.startsWith(prefijo))
+            throw new Error(`entry outside the package: ${nombre}`);
+        const ruta = nombre.slice(prefijo.length);
+        if (!rutaSegura(ruta))
+            throw new Error(`unsafe path: ${nombre}`);
+        bytes += datos.length;
+        if (salida.length >= maxFicheros || bytes > maxBytes)
+            throw new Error('package too large');
+        salida.push({ ruta, contenido: Buffer.from(datos) });
+    }
+    return salida;
+}
+export function rutaSegura(ruta) {
+    if (!ruta || ruta.includes('\\') || ruta.includes('\0') || ruta.startsWith('/'))
+        return false;
+    if (/^[A-Za-z]:/.test(ruta))
+        return false;
+    const partes = ruta.split('/');
+    return partes.every((p) => p && p !== '.' && p !== '..');
+}
+export function leerTgz(tgz, limites = {}) {
+    const maxBytes = limites.maxBytes ?? 20 * 1024 * 1024;
+    const tar = gunzipSync(tgz, { maxOutputLength: maxBytes + 2 * 1024 * 1024 });
+    return leerTar(tar, limites);
+}
+export function escribirFicheros(ficheros, destino) {
+    const base = normalize(destino + sep);
+    for (const f of ficheros) {
+        const ruta = normalize(join(destino, ...f.ruta.split('/')));
+        if (!ruta.startsWith(base))
+            throw new Error(`unsafe path: ${f.ruta}`);
+        mkdirSync(dirname(ruta), { recursive: true });
+        writeFileSync(ruta, f.contenido, { mode: f.ruta.endsWith('.js') ? 0o755 : 0o644 });
+    }
+}

package/dist/textos.js

@@ -206,19 +206,43 @@ export const TEXTOS = {
     'salir.entorno': 'You are signed in with PARALLEL_API_KEY: remove it from your environment to sign out.',
     'salir.todas': 'Signed out on {n} terminals. API keys stay active.',
     'nombre.nuevo': 'parallel-code is now called parx. Type “parx”.',
+    'estimacion.linea': '~{n} Actions (estimate)',
+    'estimacion.con': '~{n} Actions (estimate) · with {modelo}: ~{otro}',
     'update.disponible': 'parx {version} available · run `parx update`',
     'update.al_dia': 'parx {version} is the latest version.',
     'update.sin_red': 'Could not reach npm to check for a new version. Try again later.',
-    'update.lanzando': 'Updating with: {orden}',
-    'update.hecho': 'Done. parx is now up to date.',
-    'update.fallo': 'The update did not finish. Run it yourself: {orden}',
     'update.npx': 'You are running parx through npx. Use `npx @getparallel/parx@latest` to always get the latest version.',
     'update.desarrollo': 'This is a development copy of parx (not installed from npm). Update it with git pull.',
+    'update.actualizado': 'parx updated to {version}',
+    'update.actualizado_con': 'parx updated to {version} · {novedad}',
+    'update.preparada': 'parx {version} is ready · it runs the next time you open parx',
+    'update.ya_preparada': 'parx {version} is already downloaded · it runs the next time you open parx',
+    'update.no_arranco': 'parx {version} did not start · back on {actual}',
+    'update.firma': 'parx {version} is on npm but its signature could not be verified, so it was not installed. Update by hand: {orden}',
+    'update.no_se_pudo': 'parx {version} could not be downloaded or checked. Update by hand: {orden}',
+    'autoupdate.on': 'parx keeps itself up to date: new versions are downloaded in the background and start with the next session.',
+    'autoupdate.off': 'parx will not update itself. You will see a line when there is a new version; `parx update` installs it. /autoupdate on to turn it back on.',
+    'remoto.abriendo': 'Turning on remote control…',
+    'remoto.on': 'Remote control is on. Open this on your phone or any browser: {url}',
+    'remoto.escanea': 'Or scan it with your phone:',
+    'remoto.detalle': 'Everything still runs on this computer. Credentials and Bypass are only answered here.',
+    'remoto.siempre': 'Remote control will turn on every time parx opens on this computer. /remote off to stop.',
+    'remoto.off': 'Remote control is off on this computer.',
+    'remoto.no_disponible': 'Remote control is not available for your account yet.',
+    'remoto.sin_red': 'Could not turn on remote control: {motivo}. Try /remote again.',
+    'remoto.cortado_web': 'Remote control was turned off from the web.',
+    'remoto.sesion': 'Remote control stopped: sign in again with parx login.',
+    'remoto.demasiados': 'You already have 12 parx sessions with remote control open. Close one and try again.',
+    'remoto.del_movil': 'From your phone',
+    'remoto.desde_el_movil': 'from your phone',
+    'remoto.parado': 'Stopped from your phone.',
+    'remoto.solo_interactiva': 'Remote control works in an interactive session: run parx and then /remote.',
     'error.sin_saldo': 'You are out of Actions. Top up or upgrade at getparallel.net/settings/billing',
     'error.sin_acceso': 'Your account does not have parx yet: it is in testing.',
     'error.sesion': 'Your session expired. Run: parx login',
     'error.red': 'Could not reach Parallel: {detalle}',
     'error.servidor': 'Parallel could not answer right now ({detalle}). Try again.',
+    'error.ia': 'Parallel’s AI is temporarily unavailable. Your Actions weren’t charged. Try again in a minute.',
     'error.demasiado': 'This conversation is too long. Type /new to start another one.',
     'repl.adios': 'See you.',
     'repl.registro': 'Log of this session: {ruta}',
@@ -300,6 +324,7 @@ export const COMANDOS = [
     ['model', 'Swift, Stride or Summit'],
     ['folder', 'Let parx work in another folder'],
     ['lanes', 'Run 2 or 3 tasks at once'],
+    ['remote', 'Control this parx from your phone'],
     ['mission', 'Keep it running on Parallel, phone alert when done'],
     ['missions', 'Pick a mission and control it from here'],
     ['inbox', 'Answer what your missions are waiting for'],
@@ -315,6 +340,7 @@ export const COMANDOS = [
     ['tips', 'Tips when it opens: on or off'],
     ['mouse', 'Clicks and wheel in parx: on or off'],
     ['animation', 'Answers written out as they arrive: on or off'],
+    ['autoupdate', 'New versions install themselves: on or off'],
     ['log', 'Where the log of what it does is kept'],
     ['exit', 'Leave parx'],
 ];
@@ -325,6 +351,7 @@ export const ALIAS_COMANDO = {
     strength: 'model',
     folder: 'folder', 'add-folder': 'folder', carpeta: 'folder', dir: 'folder',
     lanes: 'lanes', carriles: 'lanes',
+    remote: 'remote', 'remote-control': 'remote', rc: 'remote', remoto: 'remote', phone: 'remote',
     mission: 'mission', mision: 'mission', misión: 'mission',
     missions: 'missions', misiones: 'missions',
     inbox: 'inbox', bandeja: 'inbox', approvals: 'inbox', waiting: 'inbox',
@@ -333,6 +360,7 @@ export const ALIAS_COMANDO = {
     settings: 'settings', ajustes: 'settings', preferences: 'settings',
     mouse: 'mouse', raton: 'mouse', ratón: 'mouse',
     animation: 'animation', animations: 'animation', animacion: 'animation', animación: 'animation',
+    autoupdate: 'autoupdate', 'auto-update': 'autoupdate', autoupdates: 'autoupdate', updates: 'autoupdate', autoactualizar: 'autoupdate',
     report: 'report', informe: 'report',
     teach: 'teach', class: 'teach', clase: 'teach',
     undo: 'undo', deshacer: 'undo',
@@ -343,7 +371,7 @@ export const ALIAS_COMANDO = {
     log: 'log', registro: 'log',
     exit: 'exit', quit: 'exit', salir: 'exit',
 };
-export const ALIAS_DESDE = { strength: 2 };
+export const ALIAS_DESDE = { strength: 2, rc: 2, phone: 3 };
 export const ALIAS_SI_NO = {
     on: 'si', yes: 'si', y: 'si', '1': 'si', si: 'si', 'sí': 'si',
     off: 'no', no: 'no', n: 'no', '0': 'no',
@@ -354,7 +382,7 @@ export const USO = [
     '  parx "task"                     do the task and exit',
     '  parx --lanes "task" "task" ...  2 or 3 tasks at once, each in its own lane',
     '  parx login | logout | account',
-    '  parx update                     update parx to the latest version',
+    '  parx update                     get the latest version now (parx also updates itself; /autoupdate off stops that)',
     '',
     'Options:',
     '  --mode ask|auto|read            Ask (default), Auto inside the project, Read only',
@@ -366,6 +394,7 @@ export const USO = [
     '  --ascii                         plain characters only (also NO_COLOR for no color)',
     '  --no-mouse                      leave the mouse to the terminal (no clicks or wheel in parx)',
     '  --no-animation                  show answers whole, without writing them out',
+    '  --remote                        control this session from your phone (same as /remote)',
     '  --version, --help',
     '',
     'Sign in:',
@@ -377,7 +406,15 @@ export const USO = [
     '  parx logout [--all]             sign out here, or on every terminal',
     '  PARALLEL_API_KEY=par_key_…      sign in with that key without saving anything (CI)',
     '',
+    'Remote control:',
+    '  /remote                         link and QR to control this parx from your phone or a browser',
+    '  /remote always                  turn it on every time parx opens on this computer',
+    '  /remote off                     turn it off here',
+    '',
     'Updates:',
-    '  parx checks npm for a new version at most once a day, without slowing anything down.',
-    '  PARX_NO_UPDATE_CHECK=1          turn that check off',
+    '  parx checks npm every few hours, without slowing anything down, and installs new versions',
+    '  itself: they are verified against npm’s signature and start with your next session.',
+    '  /autoupdate off                 only tell me when there is one (then: parx update)',
+    '  PARX_NO_AUTO_UPDATE=1           the same, from the environment',
+    '  PARX_NO_UPDATE_CHECK=1          never even check',
 ].join('\n');

package/dist/tui.js

@@ -289,9 +289,9 @@ function teclaDeRaton(b, x, y, soltar, botonX10) {
 }
 export const RATON_SI = '\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h';
 export const RATON_NO = '\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1006l';
-const CON_VALOR = new Set(['mode', 'model', 'tips', 'notify', 'teach', 'mouse', 'animation']);
+const CON_VALOR = new Set(['mode', 'model', 'tips', 'notify', 'teach', 'mouse', 'animation', 'autoupdate', 'remote']);
 const CON_TEXTO = new Set(['folder']);
-const SE_MANDAN_SOLOS = new Set(['teach', 'notify', 'tips', 'folder', 'mouse', 'animation']);
+const SE_MANDAN_SOLOS = new Set(['teach', 'notify', 'tips', 'folder', 'mouse', 'animation', 'autoupdate', 'remote']);
 const MODOS_DEL_MENU = ['ask', 'auto', 'read', 'bypass'];
 export function opcionesDelMenu(valor) {
     if (!valor.startsWith('/') || valor.includes('\n'))
@@ -322,10 +322,16 @@ export function opcionesDelMenu(valor) {
         ? MODOS_DEL_MENU.map((k) => [k, tt(`modo.${k}.desc`)])
         : cmd === 'model'
             ? ORDEN_DE_MODELOS.map((k) => [k, `${MODELOS[k].nombre} ${MODELOS[k].version}: ${MODELOS[k].descripcion}`])
-            : [
-                ['on', cmd === 'teach' ? 'Explain each step as it codes' : cmd === 'notify' ? 'Notify me when it finishes or needs me' : cmd === 'mouse' ? 'Click options, scroll with the wheel' : cmd === 'animation' ? 'Write answers out as they arrive' : 'Show them when parx opens'],
-                ['off', cmd === 'teach' ? 'Back to normal' : cmd === 'notify' ? 'No desktop notifications' : cmd === 'mouse' ? 'The terminal selects and scrolls as usual' : cmd === 'animation' ? 'Show answers whole, at once' : 'Don’t show them again'],
-            ];
+            : cmd === 'remote'
+                ? [
+                    ['on', 'Link and QR for your phone, for this session'],
+                    ['always', 'Every time parx opens on this computer'],
+                    ['off', 'Stop remote control here'],
+                ]
+                : [
+                    ['on', cmd === 'teach' ? 'Explain each step as it codes' : cmd === 'notify' ? 'Notify me when it finishes or needs me' : cmd === 'mouse' ? 'Click options, scroll with the wheel' : cmd === 'animation' ? 'Write answers out as they arrive' : cmd === 'autoupdate' ? 'New versions install themselves, for the next session' : 'Show them when parx opens'],
+                    ['off', cmd === 'teach' ? 'Back to normal' : cmd === 'notify' ? 'No desktop notifications' : cmd === 'mouse' ? 'The terminal selects and scrolls as usual' : cmd === 'animation' ? 'Show answers whole, at once' : cmd === 'autoupdate' ? 'Only tell me; I run parx update myself' : 'Don’t show them again'],
+                ];
     return valores
         .filter(([v]) => v.startsWith(q))
         .map(([v, d]) => ({ nombre: v, descripcion: d, completar: `${base}${v}`, enviar: true, ...(cmd === 'mode' ? { modo: v, ...(v === 'bypass' ? { peligro: true } : {}) } : {}) }));
@@ -547,7 +553,7 @@ export function componerCarril(d, ancho, alto) {
             cursor = null;
     }
     if (conPar)
-        filaEscribir += ` ${cabezaDePar()}  `;
+        filaEscribir += ` ${cabezaDePar(d.gesto)}  `;
     const tinta = (t) => (bash ? c.bash(t) : c.violeta(t));
     const linea = conPar ? `${tinta(carril(util - ANCHO_DE_PAR - 2))}${caraDePar(d.gesto)}${tinta(carril(2))}` : tinta(carril(util));
     let barra;
@@ -1485,6 +1491,19 @@ export class Superficie {
         this.ponerValor(texto);
         this.enviar();
     }
+    mandarDesdeFuera(texto) {
+        const t = /^[/!]/.test(texto.trimStart()) ? `\u2060${texto.trimStart()}` : texto;
+        if (this.resolverLectura && !this.trabajo && !this.pregunta) {
+            const r = this.resolverLectura;
+            this.resolverLectura = null;
+            this.irAlFondo();
+            this.anadir(this.bloqueDeEnvio(t));
+            r(t);
+            return;
+        }
+        this.cola.push(t);
+        this.mostrarAviso(this.cola.length > 1 ? tt('tui.en_cola_n', { n: this.cola.length }) : tt('tui.en_cola'));
+    }
     get libre() {
         return Boolean(this.resolverLectura) && !this.trabajo && !this.pregunta;
     }
@@ -1520,11 +1539,18 @@ export class Superficie {
     actualizarCarriles() {
         this.pintar();
     }
-    preguntar(texto, tipo = 'normal') {
+    preguntar(texto, tipo = 'normal', externo) {
         const o = opcionesDePregunta(tipo);
         const peligro = tipo === 'bypass';
         return new Promise((resolver) => {
-            this.mostrarPregunta({
+            let hecha = false;
+            const contestar = (r) => {
+                if (hecha)
+                    return;
+                hecha = true;
+                resolver(r);
+            };
+            const quitar = this.mostrarPregunta({
                 texto,
                 opciones: o.opciones,
                 cortas: o.cortas,
@@ -1532,7 +1558,13 @@ export class Superficie {
                 ...(peligro ? { peligro: true } : {}),
                 indiceNo: o.valores.indexOf('no'),
                 siConY: o.valores[o.elegida] !== 'no' || peligro,
-            }, (i) => resolver(i === null ? 'no' : (o.valores[i] ?? 'no')));
+            }, (i) => contestar(i === null ? 'no' : (o.valores[i] ?? 'no')));
+            externo?.then((r) => {
+                if (hecha || !o.valores.includes(r))
+                    return;
+                contestar(r);
+                quitar();
+            });
         });
     }
     elegir(texto, opciones, o = {}) {
@@ -1560,6 +1592,20 @@ export class Superficie {
             this.esperando.push(mostrar);
         else
             mostrar();
+        return () => {
+            const i = this.esperando.indexOf(mostrar);
+            if (i >= 0) {
+                this.esperando.splice(i, 1);
+                return;
+            }
+            if (this.pregunta?.resolver !== resolver)
+                return;
+            this.pregunta = null;
+            this.sobre = null;
+            this.pulsado = null;
+            this.pintar();
+            this.esperando.shift()?.();
+        };
     }
     responder(i) {
         const p = this.pregunta;