@getparallel/parx 0.6.0 → 0.8.0

package/CHANGELOG.md

@@ -6,6 +6,17 @@ changes). Entries are generated by `npm run release` from the git history of `ap
 
 <!-- Notes written under «## Unreleased» are used as the next entry instead of the git log. -->
 
+## 0.8.0 (2026-10-18)
+
+- Publicar desde parx (t464): la web construida con parx sale en <nombre>.getparallel.net o en su dominio
+
+## 0.7.0 (2026-10-18)
+
+- Un paso corto ya no tumba el plan; «Llévalo a tu negocio» lleva a la misión en marcha y sin palabras que disparen la plantilla de clientes
+- Del código al negocio (x03): «Llévalo a tu negocio» en Sesiones y /mission con el enlace de la web
+- Ver en el móvil la web que construye (x01)
+- El Mac siempre listo (x07): parx service on/off/add/remove/status, tareas abiertas desde el móvil
+
 ## 0.6.0 (2026-10-18)
 
 - parx updates itself. Every few hours it checks npm in the background; a new version is downloaded, verified (npm's registry signature against npm's public key pinned in parx, plus the package's SHA-512) and start-tested, then kept ready in `~/.config/parx/versiones`. It starts with your next session, never mid-session, with one line: «parx 0.5.1 updated · what's new». If a new version fails to start, parx goes back to the previous one on its own. `/autoupdate off` (or `PARX_NO_AUTO_UPDATE=1`) keeps the old behaviour: a line when there is a new version, and `parx update` installs it.

package/dist/api.js

@@ -128,6 +128,12 @@ export function latidoRemoto(servidor, token, id, cuerpo, señal) {
 export function ordenesRemotas(servidor, token, id, esperaMs, señal) {
     return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}/ordenes?espera=${esperaMs}`, { token, señal, plazoMs: esperaMs + 15_000 });
 }
+export function subirVistaRemota(servidor, token, id, cuerpo) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}/vista`, { token, cuerpo, plazoMs: 60_000 });
+}
+export function publicarWebRemota(servidor, token, id) {
+    return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}/publicar`, { token, cuerpo: {}, plazoMs: 90_000 });
+}
 export function cerrarRemoto(servidor, token, id, plazoMs = 3000) {
     return llamar(servidor, `/api/terminal/remoto/${encodeURIComponent(id)}`, { token, metodo: 'DELETE', plazoMs });
 }

package/dist/cli.js

@@ -9,7 +9,7 @@ import { ALIAS_COMANDO, ALIAS_SI_NO, COMANDOS, t, USO } from "./textos.js";
 import { c, capacidades, colorDeModo, fijarCapacidades, sep, signo, sinColor, SIMBOLOS } from "./marca.js";
 import { guardarAjustes, leerAjustes, migrarCarpetaVieja, VERSION } from "./config.js";
 import { MODELO_POR_DEFECTO, MODELOS, modeloDe, nombreDeModelo } from "./modelos.js";
-import { cicloDeMision, compartirMision, correoVisible, crearMision, equipo, ErrorDeParallel, leerBandeja, leerConexiones, leerCuenta, leerMisionDeLaCuenta, leerMisiones, leerPlantillas, quienEs, responderBandeja, verMision, } from "./api.js";
+import { cicloDeMision, compartirMision, correoVisible, crearMision, equipo, ErrorDeParallel, leerBandeja, leerConexiones, leerCuenta, leerMisionDeLaCuenta, leerMisiones, leerPlantillas, quienEs, responderBandeja, verMision, publicarWebRemota, } 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";
@@ -17,6 +17,8 @@ import { deshacerUltimo, permitirCarpeta } from "./herramientas.js";
 import { Registro } from "./registro.js";
 import { Pantalla } from "./ui.js";
 import { Remoto } from "./remoto.js";
+import { VistaPrevia } from "./vista.js";
+import { anadirCarpeta, carpetasDelServicio, instalarServicio, quitarCarpeta, quitarServicio, reiniciarServicio, rutaDelRegistro, servicioEnMarcha, servicioInstalado, servir } from "./servicio.js";
 import { qrEnTexto } from "./qr.js";
 import { acciones, bloqueDeBienvenida, bloqueDeLaPersona, bloqueDeTabla, duracion, Superficie } from "./tui.js";
 import { CONSEJOS, cambiarConsejos, consejo, elegirConsejos, ordenDeConsejos } from "./consejos.js";
@@ -49,6 +51,9 @@ function opciones() {
             'no-animation': { type: 'boolean' },
             animation: { type: 'boolean' },
             remote: { type: 'boolean' },
+            serve: { type: 'boolean' },
+            'remote-child': { type: 'boolean' },
+            origen: { type: 'string' },
             version: { type: 'boolean', short: 'v' },
             help: { type: 'boolean', short: 'h' },
             browser: { type: 'boolean' },
@@ -222,6 +227,62 @@ async function principal() {
         pantalla.escribir();
         return 0;
     }
+    if (v.serve) {
+        const c0 = credencialesActivas();
+        if (!c0) {
+            console.log(t('cuenta.sin_sesion'));
+            return 1;
+        }
+        return servir(c0);
+    }
+    if (primero === 'service' || primero === 'servicio') {
+        const accion = (positionals[1] ?? 'status').toLowerCase();
+        const ruta = positionals.slice(2).join(' ') || process.cwd();
+        const lista = () => carpetasDelServicio().map((x) => x.nombre).join(', ') || t('servicio.ninguna');
+        if (accion === 'add') {
+            const r = anadirCarpeta(ruta);
+            pantalla.escribir(r ? t('servicio.anadida', { ruta: rutaCorta(r, 60) }) : t('servicio.no_anadida', { ruta }));
+            if (r)
+                reiniciarServicio();
+            return r ? 0 : 1;
+        }
+        if (accion === 'remove') {
+            const ok = quitarCarpeta(positionals.slice(2).join(' '));
+            pantalla.escribir(ok ? t('servicio.quitada', { ruta: positionals.slice(2).join(' ') }) : t('servicio.no_quitada', { ruta: positionals.slice(2).join(' ') }));
+            if (ok)
+                reiniciarServicio();
+            return ok ? 0 : 1;
+        }
+        if (accion === 'on') {
+            if (process.platform !== 'darwin') {
+                pantalla.error(t('servicio.solo_mac'));
+                return 1;
+            }
+            if (!credencialesActivas()) {
+                pantalla.escribir(t('cuenta.sin_sesion'));
+                return 1;
+            }
+            if (!carpetasDelServicio().length && !anadirCarpeta(process.cwd())) {
+                pantalla.escribir(t('servicio.sin_carpetas'));
+                return 1;
+            }
+            instalarServicio();
+            pantalla.escribir(t('servicio.on', { carpetas: lista() }));
+            pantalla.escribir(c.gris(t('servicio.registro', { ruta: rutaDelRegistro() })));
+            return 0;
+        }
+        if (accion === 'off') {
+            quitarServicio();
+            pantalla.escribir(t('servicio.off'));
+            return 0;
+        }
+        if (accion === 'status') {
+            pantalla.escribir(t('servicio.estado', { estado: servicioInstalado() && servicioEnMarcha() ? t('servicio.en_marcha') : t('servicio.parado'), lista: lista() }));
+            return 0;
+        }
+        pantalla.escribir(t('servicio.uso'));
+        return 2;
+    }
     const modoPedido = (v.mode ?? v.modo);
     const pedido = modoDe(modoPedido);
     if (pedido === 'bypass') {
@@ -302,6 +363,24 @@ async function principal() {
     let superficie = null;
     let remoto = null;
     let deFueraPendientes = 0;
+    let sugeridaMision = false;
+    let vistaPrevia = new VistaPrevia();
+    const actualizarVista = async (forzar = false) => {
+        const r0 = remoto;
+        if (!r0?.encendido || !r0.id)
+            return null;
+        try {
+            const r = await vistaPrevia.actualizar({ servidor: cred.servidor, token: cred.token, remoto: r0.id, raiz });
+            if (!r)
+                return null;
+            if (r.cambiados > 0 || forzar)
+                r0.evento('vista', { url: r.url, version: r.version, archivos: r.cambiados, carpeta: r.carpeta });
+            return { url: r.url };
+        }
+        catch (e) {
+            return { error: e instanceof ErrorDeParallel ? e.codigo : 'red' };
+        }
+    };
     let bienvenida;
     let consejosDeEntrada = [];
     const confirmarNuevaEnMarcha = async () => {
@@ -397,6 +476,12 @@ async function principal() {
             superficie?.descansar();
             remoto?.fijarEstado('libre', null);
         }
+        if (remoto?.encendido)
+            void actualizarVista();
+        if (!sugeridaMision && sesion.diario.some((d) => d.ficheros.length) && superficie) {
+            sugeridaMision = true;
+            soloAqui(() => pantalla.escribir(c.gris(t('mision.sugerencia'))));
+        }
         quizaAvisar(t('aviso.termino', { tarea: texto.replace(/\s+/g, ' ').slice(0, 80) }), Date.now() - inicio);
         return seguir;
     };
@@ -434,6 +519,7 @@ async function principal() {
         try {
             const r = await nuevo.abrir({ equipo: equipo().equipo, version: equipo().version, carpeta: basename(raiz), modelo: nombreDeModelo(sesion.modelo), modo: nombreDeModo(sesion.ctx.modo) });
             remoto = nuevo;
+            vistaPrevia = new VistaPrevia();
             registro.apuntar('remoto', { encendido: true });
             enseñarEnlace(r.url, enseñarQR);
             pantalla.espejo = nuevo;
@@ -529,6 +615,63 @@ async function principal() {
         quizaAvisar(t('carriles.hecho', { n: tareas.length }), ms);
         return r.ok;
     };
+    if (v['remote-child']) {
+        const cola = [];
+        let despertar = null;
+        let cortada = false;
+        const r = new Remoto({
+            servidor: cred.servidor,
+            token: cred.token,
+            alMensaje: (texto) => {
+                cola.push(texto);
+                despertar?.();
+            },
+            alParar: () => {
+                if (ocupado)
+                    control.abort();
+            },
+            alApagarse: () => {
+                cortada = true;
+                if (ocupado)
+                    control.abort();
+                despertar?.();
+            },
+        });
+        const e = equipo();
+        try {
+            await r.abrir({ equipo: e.equipo, version: e.version, carpeta: basename(raiz), modelo: nombreDeModelo(sesion.modelo), modo: nombreDeModo(sesion.ctx.modo), ...(typeof v.origen === 'string' ? { origen: v.origen } : {}) });
+        }
+        catch {
+            return 1;
+        }
+        remoto = r;
+        pantalla.espejo = r;
+        if (tarea) {
+            deFueraPendientes++;
+            await hacer(tarea);
+        }
+        const INACTIVA_MS = 30 * 60 * 1000;
+        while (!cortada) {
+            const siguiente = cola.shift();
+            if (siguiente) {
+                deFueraPendientes++;
+                await hacer(siguiente);
+                continue;
+            }
+            const hubo = await new Promise((res) => {
+                const reloj = setTimeout(() => res(false), INACTIVA_MS);
+                despertar = () => {
+                    clearTimeout(reloj);
+                    res(true);
+                };
+            });
+            despertar = null;
+            if (!hubo)
+                break;
+        }
+        await r.cerrar();
+        return 0;
+    }
     if (tarea) {
         cabeceraCorta([c.gris([nombreDeModo(modo), nombreDeModelo(modelo), cuenta.plan, rutaCorta(raiz)].filter(Boolean).join(sep()))]);
         if (quiereBypass && (await confirmarBypass()))
@@ -1088,7 +1231,7 @@ async function principal() {
                     break;
                 }
                 case 'mission': {
-                    const objetivo = objetivoDeMision(resto, sesion.diario);
+                    const objetivo = objetivoDeMision(resto, sesion.diario, vistaPrevia.url);
                     if (!objetivo) {
                         pantalla.escribir(t('mision.nada'));
                         break;
@@ -1197,6 +1340,44 @@ async function principal() {
                     await encenderRemoto(true);
                     break;
                 }
+                case 'preview': {
+                    if (!remoto?.encendido) {
+                        pantalla.escribir(t('vista.sin_remoto'));
+                        break;
+                    }
+                    const r = await actualizarVista(true);
+                    if (!r)
+                        pantalla.escribir(t('vista.sin_web'));
+                    else if ('error' in r)
+                        pantalla.error(t('vista.no_subida', { motivo: r.error }));
+                    else
+                        pantalla.escribir(t('vista.lista', { url: c.marca(r.url) }));
+                    break;
+                }
+                case 'publish': {
+                    const r0 = remoto;
+                    if (!r0?.encendido || !r0.id) {
+                        pantalla.escribir(t('publicar.sin_remoto'));
+                        break;
+                    }
+                    const subida = await actualizarVista(true);
+                    if (!subida) {
+                        pantalla.escribir(t('vista.sin_web'));
+                        break;
+                    }
+                    if ('error' in subida) {
+                        pantalla.error(t('vista.no_subida', { motivo: subida.error }));
+                        break;
+                    }
+                    try {
+                        const p = await publicarWebRemota(cred.servidor, cred.token, r0.id);
+                        pantalla.escribir(t('publicar.lista', { url: c.marca(p.url) }));
+                    }
+                    catch (e) {
+                        pantalla.error(t('publicar.error', { motivo: e instanceof ErrorDeParallel ? `${e.codigo}${e.detalle ? ` ${e.detalle}` : ''}` : 'red' }));
+                    }
+                    break;
+                }
                 case 'autoupdate': {
                     const si = ALIAS_SI_NO[arg] ?? (autoactualizarApagada() ? 'si' : 'no');
                     guardarAjustes({ autoactualizar: si === 'si' });

package/dist/config.js

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

package/dist/mision.js

@@ -1,12 +1,13 @@
 export const MAX_OBJETIVO = 600;
-export function objetivoDeMision(meta, diario) {
+export function objetivoDeMision(meta, diario, vista = null) {
     const ultima = [...diario].reverse().find((d) => d.pedido.trim());
     const que = (meta.trim() || ultima?.pedido.trim() || '').replace(/\s+/g, ' ');
     if (que.length < 4)
         return null;
     const ficheros = [...new Set(diario.flatMap((d) => d.ficheros))].slice(0, 6);
-    const contexto = ultima
-        ? ` Context from the terminal (parx): ${ficheros.length ? `changed ${ficheros.join(', ')}. ` : ''}${ultima.respuesta ? `Last result: ${ultima.respuesta.replace(/\s+/g, ' ')}` : ''}`
+    const enlace = vista ? `preview of the website (temporary link, valid 24 hours): ${vista}. ` : '';
+    const contexto = ultima || vista
+        ? ` Context from the terminal (parx): ${enlace}${ficheros.length ? `changed ${ficheros.join(', ')}. ` : ''}${ultima?.respuesta ? `Last result: ${ultima.respuesta.replace(/\s+/g, ' ')}` : ''}`
         : '';
     const base = que.length > MAX_OBJETIVO ? `${que.slice(0, MAX_OBJETIVO - 1)}…` : que;
     const sitio = MAX_OBJETIVO - base.length;

package/dist/remoto.js

@@ -242,9 +242,20 @@ export class Remoto {
             return;
         }
         if (orden.tipo === 'parar') {
+            for (const [id, p] of this.preguntas) {
+                this.preguntas.delete(id);
+                p.resolver('no');
+            }
             this.o.alParar();
             return;
         }
+        if (orden.tipo === 'abrir') {
+            const carpeta = typeof orden.datos.carpeta === 'string' ? orden.datos.carpeta : '';
+            const texto = typeof orden.datos.texto === 'string' ? orden.datos.texto.trim().slice(0, MAX_TEXTO) : '';
+            if (carpeta && texto)
+                this.o.alAbrir?.({ orden: orden.id, carpeta, texto });
+            return;
+        }
         if (orden.tipo === 'respuesta') {
             const id = String(orden.datos.pregunta ?? '');
             const valor = orden.datos.valor;

package/dist/servicio.js

@@ -0,0 +1,191 @@
+import { spawn, execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, openSync, realpathSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { homedir, hostname } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { equipo, ErrorDeParallel } from "./api.js";
+import { guardarAjustes, leerAjustes } from "./config.js";
+import { Remoto } from "./remoto.js";
+export const ETIQUETA = 'net.getparallel.parx';
+export const MAX_SESIONES = 3;
+export function idDeCarpeta(ruta) {
+    return createHash('sha256').update(ruta).digest('hex').slice(0, 16);
+}
+export function carpetasDelServicio(rutas = leerAjustes().carpetasRemotas ?? []) {
+    return rutas
+        .filter((r) => {
+        try {
+            return existsSync(r) && statSync(r).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    })
+        .map((ruta) => ({ id: idDeCarpeta(ruta), nombre: basename(ruta) || ruta, ruta }));
+}
+export function anadirCarpeta(ruta) {
+    const abs = resolve(ruta);
+    if (!existsSync(abs) || !statSync(abs).isDirectory())
+        return null;
+    const real = realpathSync(abs);
+    if (real === homedir() || real === '/' || real === realpathSync(homedir()))
+        return null;
+    const lista = leerAjustes().carpetasRemotas ?? [];
+    if (!lista.includes(real))
+        guardarAjustes({ carpetasRemotas: [...lista, real].slice(-20) });
+    return real;
+}
+export function quitarCarpeta(ruta) {
+    const lista = leerAjustes().carpetasRemotas ?? [];
+    let real = resolve(ruta);
+    try {
+        real = realpathSync(real);
+    }
+    catch {
+    }
+    const queda = lista.filter((x) => x !== real && basename(x) !== ruta);
+    guardarAjustes({ carpetasRemotas: queda });
+    return queda.length !== lista.length;
+}
+export const rutaDelPlist = () => join(homedir(), 'Library', 'LaunchAgents', `${ETIQUETA}.plist`);
+export const rutaDelRegistro = () => join(homedir(), 'Library', 'Logs', 'parx-service.log');
+const xml = (s) => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+export function plistDelServicio(o) {
+    const args = [o.node, ...o.argumentos, '--serve'].map((a) => `    <string>${xml(a)}</string>`).join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${ETIQUETA}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <dict>
+    <key>SuccessfulExit</key>
+    <false/>
+  </dict>
+  <key>ThrottleInterval</key>
+  <integer>30</integer>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${xml(o.path)}</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${xml(o.registro)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(o.registro)}</string>
+</dict>
+</plist>
+`;
+}
+const dominio = () => `gui/${process.getuid?.() ?? 501}`;
+export function servicioInstalado() {
+    return existsSync(rutaDelPlist());
+}
+export function instalarServicio() {
+    if (process.platform !== 'darwin')
+        throw new Error('solo_mac');
+    const plist = rutaDelPlist();
+    mkdirSync(join(homedir(), 'Library', 'LaunchAgents'), { recursive: true });
+    mkdirSync(join(homedir(), 'Library', 'Logs'), { recursive: true });
+    writeFileSync(plist, plistDelServicio({ node: process.execPath, argumentos: [...process.execArgv, process.argv[1]], path: process.env.PATH ?? '/usr/bin:/bin', registro: rutaDelRegistro() }), { mode: 0o644 });
+    try {
+        execFileSync('launchctl', ['bootout', `${dominio()}/${ETIQUETA}`], { stdio: 'ignore' });
+    }
+    catch {
+    }
+    execFileSync('launchctl', ['bootstrap', dominio(), plist], { stdio: 'ignore' });
+}
+export function reiniciarServicio() {
+    if (!servicioInstalado())
+        return;
+    try {
+        execFileSync('launchctl', ['kickstart', '-k', `${dominio()}/${ETIQUETA}`], { stdio: 'ignore' });
+    }
+    catch {
+    }
+}
+export function quitarServicio() {
+    try {
+        execFileSync('launchctl', ['bootout', `${dominio()}/${ETIQUETA}`], { stdio: 'ignore' });
+    }
+    catch {
+    }
+    rmSync(rutaDelPlist(), { force: true });
+}
+export function servicioEnMarcha() {
+    try {
+        execFileSync('launchctl', ['print', `${dominio()}/${ETIQUETA}`], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const log = (...a) => console.log(new Date().toISOString(), ...a);
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+export function lanzarSesion(o) {
+    const salida = openSync(rutaDelRegistro(), 'a');
+    return spawn(process.execPath, [...process.execArgv, process.argv[1], '--remote-child', '--origen', o.orden, '--dir', o.ruta, '--', o.texto], {
+        cwd: o.ruta,
+        stdio: ['ignore', salida, salida],
+        env: { ...process.env, PARX_NO_UPDATE_CHECK: '1' },
+    });
+}
+export async function servir(cred) {
+    const carpetas = carpetasDelServicio();
+    if (!carpetas.length) {
+        log('no folders: run `parx service add` in a project folder');
+        return 0;
+    }
+    let vivas = 0;
+    let fin = null;
+    const terminado = new Promise((r) => (fin = r));
+    const remoto = new Remoto({
+        servidor: cred.servidor,
+        token: cred.token,
+        alMensaje: () => { },
+        alParar: () => { },
+        alAbrir: ({ orden, carpeta, texto }) => {
+            const c = carpetasDelServicio().find((x) => x.id === carpeta);
+            if (!c)
+                return log('open: unknown folder', carpeta);
+            if (vivas >= MAX_SESIONES)
+                return log('open: too many sessions');
+            vivas++;
+            log('open', c.nombre);
+            const hijo = lanzarSesion({ ruta: c.ruta, orden, texto });
+            hijo.on('exit', () => vivas--);
+        },
+        alApagarse: (motivo) => {
+            log('stopped:', motivo);
+            fin?.(motivo === 'web' ? 0 : 1);
+        },
+    });
+    const e = equipo();
+    for (let pausa = 5000;; pausa = Math.min(300_000, pausa * 2)) {
+        try {
+            await remoto.abrir({ tipo: 'servicio', carpetas: carpetas.map(({ id, nombre }) => ({ id, nombre })), equipo: e.equipo || hostname(), version: e.version, carpeta: '', modelo: '', modo: '' });
+            log('listening:', carpetas.map((c) => c.nombre).join(', '));
+            break;
+        }
+        catch (err) {
+            if (err instanceof ErrorDeParallel && (err.codigo === 'sesion' || err.codigo === 'sin_acceso')) {
+                log('cannot start:', err.codigo);
+                return 1;
+            }
+            log('no connection, retrying');
+            await dormir(pausa);
+        }
+    }
+    const salir = () => void remoto.cerrar().finally(() => fin?.(0));
+    process.on('SIGTERM', salir);
+    process.on('SIGINT', salir);
+    return terminado;
+}

package/dist/textos.js

@@ -237,6 +237,28 @@ export const TEXTOS = {
     '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.',
+    'mision.sugerencia': 'Next: /mission send it to my client · or announce it, or charge for it. It asks before sending anything.',
+    'vista.lista': 'Preview on your phone (updates after each task): {url} · /publish puts it online.',
+    'vista.sin_remoto': 'Turn on /remote first: the preview opens from your phone.',
+    'vista.sin_web': 'No web to preview: there is no index.html here or in dist/, build/ or out/.',
+    'vista.no_subida': 'The preview could not be uploaded: {motivo}.',
+    'publicar.lista': 'Live at {url} · the same address every time you /publish. Your own domain: from Sessions on your phone.',
+    'publicar.sin_remoto': 'Turn on /remote first: publishing goes through your Parallel account.',
+    'publicar.error': 'Could not publish: {motivo}.',
+    'servicio.on': 'Your Mac is ready. From Sessions on your phone you can start a task in: {carpetas}. It starts again every time you log in.',
+    'servicio.off': 'The service is off. Your phone can no longer start tasks on this Mac.',
+    'servicio.anadida': 'Added {ruta}. Your phone can start tasks there.',
+    'servicio.no_anadida': '{ruta} cannot be added: it must be an existing folder, and not your whole home folder.',
+    'servicio.quitada': 'Removed {ruta}.',
+    'servicio.no_quitada': '{ruta} was not in the list.',
+    'servicio.estado': 'Service: {estado}. Folders: {lista}.',
+    'servicio.en_marcha': 'running',
+    'servicio.parado': 'off',
+    'servicio.ninguna': 'none',
+    'servicio.sin_carpetas': 'Add a folder first: go to a project folder and run parx service add.',
+    'servicio.solo_mac': 'The service is only for macOS for now.',
+    'servicio.registro': 'Log: {ruta}',
+    'servicio.uso': 'parx service on | off | add [folder] | remove <folder> | status',
     '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',
@@ -325,6 +347,8 @@ export const COMANDOS = [
     ['folder', 'Let parx work in another folder'],
     ['lanes', 'Run 2 or 3 tasks at once'],
     ['remote', 'Control this parx from your phone'],
+    ['preview', 'See the web it is building on your phone'],
+    ['publish', 'Put the web online at name.getparallel.net'],
     ['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'],
@@ -352,6 +376,8 @@ export const ALIAS_COMANDO = {
     folder: 'folder', 'add-folder': 'folder', carpeta: 'folder', dir: 'folder',
     lanes: 'lanes', carriles: 'lanes',
     remote: 'remote', 'remote-control': 'remote', rc: 'remote', remoto: 'remote', phone: 'remote',
+    preview: 'preview', vista: 'preview', previa: 'preview',
+    publish: 'publish', publica: 'publish', publicar: 'publish', deploy: 'publish', online: 'publish',
     mission: 'mission', mision: 'mission', misión: 'mission',
     missions: 'missions', misiones: 'missions',
     inbox: 'inbox', bandeja: 'inbox', approvals: 'inbox', waiting: 'inbox',
@@ -410,6 +436,9 @@ export const USO = [
     '  /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',
+    '  parx service add                let your phone start tasks in this folder (macOS)',
+    '  parx service on                 keep your Mac ready at login, even with parx closed',
+    '  parx service off | status       stop it, or see how it is',
     '',
     'Updates:',
     '  parx checks npm every few hours, without slowing anything down, and installs new versions',

package/dist/ui.js

@@ -308,6 +308,16 @@ export class Pantalla {
         }
         this.pausarLinea();
         if (!this.tty || !this.rl) {
+            if (this.espejo) {
+                const op = opcionesDePregunta(tipo);
+                const remota = this.espejo.preguntaRemota(sinColor(texto), tipo, op.opciones.map((etiqueta, i) => ({ etiqueta, valor: op.valores[i] })));
+                if (remota.deFuera) {
+                    const r = await remota.deFuera;
+                    remota.contestada(r, 'movil');
+                    return r;
+                }
+                remota.contestada('no', 'ordenador');
+            }
             this.aviso(`${texto} → ${t('aviso.rechazado')}`);
             return 'no';
         }

package/dist/vista.js

@@ -0,0 +1,133 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import { subirVistaRemota } from "./api.js";
+export const EXTENSIONES = ['html', 'htm', 'css', 'js', 'mjs', 'json', 'webmanifest', 'txt', 'xml', 'svg', 'png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'ico', 'woff', 'woff2', 'ttf', 'otf', 'mp4', 'webm', 'mp3', 'wav', 'map'];
+const EXT = new Set(EXTENSIONES);
+const SALTAR = new Set(['node_modules', '.git', '.next', '.turbo', '.cache', 'coverage', '__pycache__', '.venv', 'venv', 'target']);
+export const MAX_ARCHIVOS = 300;
+export const MAX_ARCHIVO = 5 * 1024 * 1024;
+export const MAX_TOTAL = 25 * 1024 * 1024;
+const LOTE = 2_300_000;
+export function raizWeb(raiz) {
+    for (const c of ['dist', 'build', 'out', '.', 'public', 'docs', 'site']) {
+        const abs = c === '.' ? raiz : join(raiz, c);
+        try {
+            if (existsSync(join(abs, 'index.html')) && statSync(join(abs, 'index.html')).isFile())
+                return { abs, nombre: c };
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function recogerWeb(abs) {
+    const out = [];
+    let total = 0;
+    const recorrer = (dir, profundidad) => {
+        if (profundidad > 8 || out.length >= MAX_ARCHIVOS)
+            return;
+        let entradas;
+        try {
+            entradas = readdirSync(dir).sort();
+        }
+        catch {
+            return;
+        }
+        for (const n of entradas) {
+            if (out.length >= MAX_ARCHIVOS)
+                return;
+            if (n.startsWith('.') || SALTAR.has(n))
+                continue;
+            const ruta = join(dir, n);
+            let st;
+            try {
+                st = statSync(ruta);
+            }
+            catch {
+                continue;
+            }
+            if (st.isDirectory()) {
+                recorrer(ruta, profundidad + 1);
+                continue;
+            }
+            const ext = (/\.([a-z0-9]+)$/i.exec(n)?.[1] ?? '').toLowerCase();
+            if (!st.isFile() || !EXT.has(ext) || st.size > MAX_ARCHIVO || total + st.size > MAX_TOTAL)
+                continue;
+            const rel = relative(abs, ruta).split(sep).join('/');
+            if (!/^[A-Za-z0-9._\-/@+ ()]+$/.test(rel) || rel.length > 200)
+                continue;
+            const datos = readFileSync(ruta);
+            total += st.size;
+            out.push({ ruta: rel, abs: ruta, hash: createHash('sha256').update(datos).digest('hex'), tam: st.size });
+        }
+    };
+    recorrer(abs, 0);
+    return out;
+}
+export function enTandas(lista, max = LOTE) {
+    const tandas = [];
+    let actual = [];
+    let peso = 0;
+    for (const a of lista) {
+        if (actual.length && peso + a.tam > max) {
+            tandas.push(actual);
+            actual = [];
+            peso = 0;
+        }
+        actual.push(a);
+        peso += a.tam;
+    }
+    tandas.push(actual);
+    return tandas;
+}
+export class VistaPrevia {
+    token = randomBytes(32).toString('base64url');
+    subirLote;
+    constructor(subirLote = subirVistaRemota) {
+        this.subirLote = subirLote;
+    }
+    subidos = new Map();
+    url = null;
+    version = 0;
+    enMarcha = null;
+    async actualizar(o) {
+        while (this.enMarcha)
+            await this.enMarcha.catch(() => undefined);
+        const p = this.subir(o);
+        this.enMarcha = p;
+        try {
+            return await p;
+        }
+        finally {
+            this.enMarcha = null;
+        }
+    }
+    async subir(o) {
+        const web = raizWeb(o.raiz);
+        if (!web)
+            return null;
+        const lista = recogerWeb(web.abs);
+        if (!lista.some((a) => a.ruta === 'index.html'))
+            return null;
+        const cambiados = lista.filter((a) => this.subidos.get(a.ruta) !== a.hash);
+        const iguales = cambiados.length === 0 && lista.length === this.subidos.size;
+        if (iguales && this.url)
+            return { url: this.url, version: this.version, cambiados: 0, carpeta: web.nombre };
+        const tandas = enTandas(cambiados);
+        for (let i = 0; i < tandas.length; i++) {
+            const ultima = i === tandas.length - 1;
+            const archivos = tandas[i].map((a) => ({ ruta: a.ruta, datos: readFileSync(a.abs).toString('base64') }));
+            const r = await this.subirLote(o.servidor, o.token, o.remoto, {
+                archivos,
+                ...(ultima ? { raiz: web.nombre, token: this.token, lista: lista.map(({ ruta, hash, tam }) => ({ ruta, hash, tam })) } : {}),
+            });
+            if (ultima) {
+                this.url = r.url;
+                this.version = r.version;
+            }
+        }
+        this.subidos = new Map(lista.map((a) => [a.ruta, a.hash]));
+        return { url: this.url, version: this.version, cambiados: cambiados.length, carpeta: web.nombre };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getparallel/parx",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "parx: the coding agent of Parallel in your terminal. Reads and edits your project, runs commands and tests, and does coding tasks end to end. Mac, Windows and Linux.",
   "keywords": [
     "parx",