@getparallel/parx 0.5.0 → 0.6.0

package/dist/ui.js

@@ -47,6 +47,7 @@ export class Pantalla {
     esperaActiva = null;
     trabajoEnLinea = null;
     carril;
+    espejo = null;
     tty;
     constructor(rl, tty = Boolean(process.stdout.isTTY && process.stdin.isTTY), carril = null) {
         this.rl = rl;
@@ -110,6 +111,8 @@ export class Pantalla {
             this.pintarEnLinea();
     }
     escribir(linea = '', grupo = 'nota') {
+        if (linea.trim())
+            this.espejo?.evento('nota', { texto: sinColor(linea).trim() });
         if (!linea.trim()) {
             if (!this.terminaEnBlanco() && !this.carril)
                 this.bloque(() => [''], this.ultimoGrupo ?? 'nota');
@@ -119,6 +122,7 @@ export class Pantalla {
     }
     lecturas = null;
     accion(verbo, objeto, nota = '') {
+        this.espejo?.evento('accion', { verbo: sinColor(verbo), objeto: sinColor(objeto), nota: sinColor(nota) });
         if (this.superficie && verbo === t('herr.leer')) {
             const l = this.lecturas;
             if (l && this.superficie.ultimoBloque() === l.bloque) {
@@ -146,6 +150,7 @@ export class Pantalla {
             .filter((l) => l.trim() !== '' && !RELLENO_DE_TESTS.test(l));
         if (!lineas.length)
             return;
+        this.espejo?.evento('salida', { lineas: lineas.slice(-6).map((l) => sinColor(l)) });
         const ultimas = lineas.slice(-maxLineas);
         const sobran = lineas.length - ultimas.length;
         this.bloque((ancho) => {
@@ -160,15 +165,19 @@ export class Pantalla {
         }, 'accion');
     }
     detalle(texto, error = false) {
+        this.espejo?.evento('detalle', { texto: sinColor(texto), error });
         this.bloque((ancho) => [`${' '.repeat(MARGEN + sangriaDeDetalle())}${recortar(error ? c.error(`${SIMBOLOS.falla} ${texto}`) : c.gris(texto), anchoUtil(ancho) - sangriaDeDetalle())}`], 'accion');
     }
     aviso(texto) {
+        this.espejo?.evento('aviso', { texto: sinColor(texto) });
         this.bloque(bloqueDeTexto(`${c.aviso('!')} ${texto}`, '  '), 'aviso');
     }
     error(texto) {
+        this.espejo?.evento('error', { texto: sinColor(texto) });
         this.bloque(bloqueDeTexto(`${c.error(SIMBOLOS.falla)} ${texto}`, '  '), 'error');
     }
     cierre(texto) {
+        this.espejo?.evento('cierre', { texto: sinColor(texto) });
         this.bloque(bloqueDeCierre(texto, c.ok(SIMBOLOS.hecho)), 'cierre');
     }
     trabajoPropio() {
@@ -205,6 +214,7 @@ export class Pantalla {
         process.stdout.write(`\r\x1b[2K${' '.repeat(MARGEN)}${recortar(filaDeTrabajo(this.trabajoEnLinea, Date.now()), ancho - MARGEN - 2)}`);
     }
     progreso(acciones) {
+        this.espejo?.progreso(acciones);
         if (this.carril) {
             this.carril.trabajo.acciones = acciones;
             this.superficie?.actualizarCarriles();
@@ -236,6 +246,10 @@ export class Pantalla {
     }
     diff(lineas, max = 40) {
         const visibles = trozos(lineas);
+        this.espejo?.evento('diff', {
+            lineas: visibles.slice(0, 40).map((l) => (l === null ? { tipo: '⋮', texto: '' } : { tipo: l.tipo, texto: l.texto, num: l.despues ?? l.antes ?? null })),
+            mas: Math.max(0, visibles.length - 40),
+        });
         this.bloque((ancho) => {
             const s = sangriaDeDetalle();
             const util = anchoUtil(ancho) - s;
@@ -270,7 +284,21 @@ export class Pantalla {
             this.aviso(o.aviso);
         const texto = this.carril ? `${t('carriles.carril', { n: this.carril.numero })}: ${pregunta}` : pregunta;
         if (this.superficie) {
-            const r = await this.superficie.preguntar(texto, tipo);
+            const op = opcionesDePregunta(tipo);
+            const remota = this.espejo?.preguntaRemota(sinColor(texto), tipo, op.opciones.map((etiqueta, i) => ({ etiqueta, valor: op.valores[i] }))) ?? null;
+            let desdeFuera = false;
+            const externo = remota?.deFuera?.then((r) => {
+                desdeFuera = true;
+                return r;
+            });
+            const r = await this.superficie.preguntar(texto, tipo, externo);
+            remota?.contestada(r, desdeFuera ? 'movil' : 'ordenador');
+            if (desdeFuera) {
+                const o2 = opcionesDePregunta(tipo);
+                const etiqueta = o2.opciones[o2.valores.indexOf(r)] ?? t('tui.no');
+                this.bloque(bloqueDeTexto(`${c.gris('?')} ${texto} ${c.gris('→')} ${r === 'no' ? c.gris(etiqueta) : c.marca(etiqueta)} ${c.gris(`· ${t('remoto.desde_el_movil')}`)}`, '  '), 'aviso');
+                return r;
+            }
             if (r !== 'si' && tipo !== 'bypass') {
                 const o2 = opcionesDePregunta(tipo);
                 const etiqueta = o2.opciones[o2.valores.indexOf(r)] ?? t('tui.no');
@@ -293,6 +321,10 @@ export class Pantalla {
         }
     }
     texto(md) {
+        this.espejo?.evento('texto', { md });
+        this.pintarTexto(md);
+    }
+    pintarTexto(md) {
         this.terminarRevelado();
         this.bloque(bloqueDeMarkdown(md), 'texto');
     }
@@ -304,10 +336,11 @@ export class Pantalla {
         f?.();
     }
     textoAnimado(md, o = {}) {
+        this.espejo?.evento('texto', { md });
         this.terminarRevelado();
         const conSuperficie = this.superficie !== null;
         if (!this.animar || this.carril || !this.tty || (!conSuperficie && !process.stdout.isTTY)) {
-            this.texto(md);
+            this.pintarTexto(md);
             return Promise.resolve();
         }
         const completo = bloqueDeMarkdown(md);

package/dist/versiones.js

@@ -0,0 +1,341 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { carpetaDeConfiguracion, leerAjustes, VERSION } from "./config.js";
+import { comprobacionApagada, esMasNueva, ordenDeActualizar, PAQUETE, PAQUETE_EN_URL, partes, rutaDelCli } from "./actualizar.js";
+import { clavesDeConfianza, firmaValida, integridadCoincide } from "./firmas.js";
+import { escribirFicheros, leerTgz } from "./tar.js";
+export const CARPETA = 'versiones';
+const ESTADO = 'estado.json';
+const MAX_TGZ = 20 * 1024 * 1024;
+const PLAZO_DESCARGA_MS = 60_000;
+const PLAZO_ARRANQUE_MS = 20_000;
+const GUARDAR = 2;
+export function carpetaDeVersiones(dir = carpetaDeConfiguracion()) {
+    return join(dir, CARPETA);
+}
+export function leerEstado(dir = carpetaDeConfiguracion()) {
+    try {
+        const e = JSON.parse(readFileSync(join(carpetaDeVersiones(dir), ESTADO), 'utf8'));
+        const candidatas = {};
+        for (const [v, c] of Object.entries(e.candidatas ?? {})) {
+            if (!partes(v) || !c || typeof c !== 'object')
+                continue;
+            const x = c;
+            candidatas[v] = {
+                descargada: typeof x.descargada === 'string' ? x.descargada : '',
+                probada: x.probada === true,
+                intentos: typeof x.intentos === 'number' && x.intentos >= 0 ? Math.floor(x.intentos) : 0,
+                arranca: x.arranca === true,
+                anunciada: x.anunciada === true,
+                ...(typeof x.mala === 'string' ? { mala: x.mala } : {}),
+                ...(typeof x.novedad === 'string' ? { novedad: x.novedad } : {}),
+            };
+        }
+        return { candidatas };
+    }
+    catch {
+        return { candidatas: {} };
+    }
+}
+export function guardarEstado(e, dir = carpetaDeConfiguracion()) {
+    try {
+        const carpeta = carpetaDeVersiones(dir);
+        if (!existsSync(carpeta))
+            mkdirSync(carpeta, { recursive: true, mode: 0o700 });
+        writeFileSync(join(carpeta, ESTADO), JSON.stringify(e, null, 2), { mode: 0o600 });
+    }
+    catch {
+    }
+}
+export function autoactualizarApagada(env = process.env, ajustes = leerAjustes()) {
+    const si = (x) => Boolean(x && x !== '0' && x.toLowerCase() !== 'false');
+    return comprobacionApagada(env) || si(env.PARX_NO_AUTO_UPDATE) || ajustes.autoactualizar === false;
+}
+export function gestorPermiteAutoactualizar(gestor) {
+    return gestor !== 'npx' && gestor !== 'desarrollo';
+}
+export function rutaDeLaVersion(version, dir = carpetaDeConfiguracion()) {
+    const carpeta = join(carpetaDeVersiones(dir), version);
+    return { carpeta, cli: join(carpeta, 'dist', 'cli.js') };
+}
+export function novedadDelChangelog(texto, version) {
+    const re = new RegExp(`^## ${version.replace(/\./g, '\\.')}\\b[^\\n]*\\n([\\s\\S]*?)(?=^## |(?![\\s\\S]))`, 'm');
+    const m = re.exec(texto);
+    if (!m)
+        return null;
+    const linea = m[1].split('\n').map((l) => l.trim()).find((l) => /^[-*]\s+\S/.test(l));
+    if (!linea)
+        return null;
+    const limpia = linea
+        .replace(/^[-*]\s+/, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, '$1')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!limpia)
+        return null;
+    const frase = (/^(.{20,}?\.)\s/.exec(limpia)?.[1] ?? limpia).replace(/[;:,]$/, '');
+    if (frase.length <= 140)
+        return frase;
+    const corte = frase.slice(0, 139);
+    const espacio = corte.lastIndexOf(' ');
+    return `${(espacio > 80 ? corte.slice(0, espacio) : corte).replace(/[\s;:,.]+$/, '')}…`;
+}
+function registroDe(opts) {
+    return (opts.registro ?? opts.env?.PARX_REGISTRY ?? process.env.PARX_REGISTRY ?? 'https://registry.npmjs.org').replace(/\/+$/, '');
+}
+export async function manifiestoDe(version, opts = {}) {
+    const registro = registroDe(opts);
+    try {
+        const r = await (opts.fetch ?? fetch)(`${registro}/${PAQUETE_EN_URL}/${version}`, {
+            headers: { accept: 'application/json', 'user-agent': `parx/${VERSION}` },
+            signal: AbortSignal.timeout(opts.plazoMs ?? 10_000),
+        });
+        if (!r.ok)
+            return null;
+        const j = (await r.json());
+        if (j.version !== version || !j.dist || typeof j.dist.integrity !== 'string' || typeof j.dist.tarball !== 'string')
+            return null;
+        return { version, integrity: j.dist.integrity, tarball: j.dist.tarball, firmas: j.dist.signatures };
+    }
+    catch {
+        return null;
+    }
+}
+export function tarballDelRegistro(tarball, registro) {
+    try {
+        const t = new URL(tarball);
+        const r = new URL(registro);
+        if (t.host !== r.host)
+            return false;
+        if (t.protocol !== r.protocol)
+            return false;
+        return t.protocol === 'https:' || t.hostname === '127.0.0.1' || t.hostname === 'localhost';
+    }
+    catch {
+        return false;
+    }
+}
+async function bajar(url, opts) {
+    try {
+        const r = await (opts.fetch ?? fetch)(url, { headers: { 'user-agent': `parx/${VERSION}` }, signal: AbortSignal.timeout(opts.plazoMs ?? PLAZO_DESCARGA_MS) });
+        if (!r.ok)
+            return null;
+        const largo = Number(r.headers.get('content-length') ?? 0);
+        if (largo > MAX_TGZ)
+            return null;
+        const b = Buffer.from(await r.arrayBuffer());
+        return b.length > MAX_TGZ ? null : b;
+    }
+    catch {
+        return null;
+    }
+}
+export function probarQueArranca(cli, version, opts = {}) {
+    const env = { ...(opts.env ?? process.env), PARX_LANZADO_DESDE: 'prueba', PARX_NO_UPDATE_CHECK: '1' };
+    delete env.PARX_PRUEBAS;
+    return new Promise((resolver) => {
+        execFile(opts.node ?? process.execPath, [cli, '--version'], { env, timeout: opts.plazoMs ?? PLAZO_ARRANQUE_MS, windowsHide: true }, (error, stdout) => {
+            resolver(!error && String(stdout).trim() === `parx ${version}`);
+        });
+    });
+}
+export async function prepararVersion(version, opts = {}) {
+    const dir = opts.dir ?? carpetaDeConfiguracion();
+    if (!partes(version))
+        return { ok: false, motivo: 'manifiesto' };
+    const estado = leerEstado(dir);
+    const ya = estado.candidatas[version];
+    const { carpeta, cli } = rutaDeLaVersion(version, dir);
+    if (ya?.probada && !ya.mala && existsSync(cli))
+        return { ok: true, version, novedad: ya.novedad ?? null, yaEstaba: true };
+    const registro = registroDe(opts);
+    const m = await manifiestoDe(version, opts);
+    if (!m)
+        return { ok: false, motivo: 'manifiesto' };
+    if (!tarballDelRegistro(m.tarball, registro))
+        return { ok: false, motivo: 'manifiesto' };
+    const claves = opts.claves ?? clavesDeConfianza(opts.env ?? process.env);
+    if (!firmaValida({ nombre: PAQUETE, version, integrity: m.integrity, firmas: m.firmas }, claves))
+        return { ok: false, motivo: 'firma' };
+    const tgz = await bajar(m.tarball, opts);
+    if (!tgz)
+        return { ok: false, motivo: 'descarga' };
+    if (!integridadCoincide(tgz, m.integrity))
+        return { ok: false, motivo: 'integridad' };
+    let ficheros;
+    try {
+        ficheros = leerTgz(tgz);
+    }
+    catch {
+        return { ok: false, motivo: 'contenido' };
+    }
+    const pkg = ficheros.find((f) => f.ruta === 'package.json');
+    let manifiesto = {};
+    try {
+        manifiesto = pkg ? JSON.parse(pkg.contenido.toString('utf8')) : {};
+    }
+    catch {
+    }
+    if (manifiesto.name !== PAQUETE || manifiesto.version !== version || !ficheros.some((f) => f.ruta === 'dist/cli.js'))
+        return { ok: false, motivo: 'contenido' };
+    const temporal = `${carpeta}.tmp`;
+    try {
+        rmSync(temporal, { recursive: true, force: true });
+        rmSync(carpeta, { recursive: true, force: true });
+        mkdirSync(temporal, { recursive: true, mode: 0o700 });
+        escribirFicheros(ficheros, temporal);
+    }
+    catch {
+        rmSync(temporal, { recursive: true, force: true });
+        return { ok: false, motivo: 'disco' };
+    }
+    const arranca = await probarQueArranca(join(temporal, 'dist', 'cli.js'), version, { node: opts.node, env: opts.env });
+    if (!arranca) {
+        rmSync(temporal, { recursive: true, force: true });
+        const e = leerEstado(dir);
+        e.candidatas[version] = { descargada: new Date(opts.ahora ?? Date.now()).toISOString(), probada: false, intentos: 0, arranca: false, anunciada: false, mala: 'no_arranca' };
+        guardarEstado(e, dir);
+        return { ok: false, motivo: 'no_arranca' };
+    }
+    try {
+        renameSync(temporal, carpeta);
+    }
+    catch {
+        rmSync(temporal, { recursive: true, force: true });
+        return { ok: false, motivo: 'disco' };
+    }
+    const changelog = ficheros.find((f) => f.ruta === 'CHANGELOG.md');
+    const novedad = changelog ? novedadDelChangelog(changelog.contenido.toString('utf8'), version) : null;
+    const e = leerEstado(dir);
+    e.candidatas[version] = { descargada: new Date(opts.ahora ?? Date.now()).toISOString(), probada: true, intentos: 0, arranca: false, anunciada: false, ...(novedad ? { novedad } : {}) };
+    guardarEstado(e, dir);
+    limpiarVersiones(dir);
+    return { ok: true, version, novedad, yaEstaba: false };
+}
+export function limpiarVersiones(dir = carpetaDeConfiguracion()) {
+    const e = leerEstado(dir);
+    const carpeta = carpetaDeVersiones(dir);
+    const buenas = Object.entries(e.candidatas)
+        .filter(([, c]) => c.probada && !c.mala)
+        .map(([v]) => v)
+        .sort((a, b) => (esMasNueva(a, b) ? -1 : esMasNueva(b, a) ? 1 : 0));
+    const quedarse = new Set(buenas.slice(0, GUARDAR));
+    let entradas = [];
+    try {
+        entradas = readdirSync(carpeta);
+    }
+    catch {
+        return;
+    }
+    for (const nombre of entradas) {
+        if (nombre === ESTADO)
+            continue;
+        if (!quedarse.has(nombre)) {
+            rmSync(join(carpeta, nombre), { recursive: true, force: true });
+            if (e.candidatas[nombre] && !e.candidatas[nombre].mala)
+                delete e.candidatas[nombre];
+        }
+    }
+    guardarEstado(e, dir);
+}
+export function marcarMala(version, motivo, dir = carpetaDeConfiguracion()) {
+    const e = leerEstado(dir);
+    const c = e.candidatas[version];
+    if (c)
+        c.mala = motivo;
+    else
+        e.candidatas[version] = { descargada: '', probada: false, intentos: 0, arranca: false, anunciada: false, mala: motivo };
+    guardarEstado(e, dir);
+    rmSync(rutaDeLaVersion(version, dir).carpeta, { recursive: true, force: true });
+}
+export function elegirVersionParaArrancar(opts = {}) {
+    const dir = opts.dir ?? carpetaDeConfiguracion();
+    const actual = opts.actual ?? VERSION;
+    const e = leerEstado(dir);
+    let retirada = null;
+    let cambios = false;
+    for (const [v, c] of Object.entries(e.candidatas)) {
+        if (!esMasNueva(v, actual)) {
+            rmSync(rutaDeLaVersion(v, dir).carpeta, { recursive: true, force: true });
+            delete e.candidatas[v];
+            cambios = true;
+            continue;
+        }
+        if (c.probada && !c.mala && !c.arranca && c.intentos >= 2) {
+            c.mala = 'no_confirmo';
+            rmSync(rutaDeLaVersion(v, dir).carpeta, { recursive: true, force: true });
+            retirada = v;
+            cambios = true;
+        }
+    }
+    const validas = Object.entries(e.candidatas)
+        .filter(([v, c]) => c.probada && !c.mala && existsSync(rutaDeLaVersion(v, dir).cli))
+        .map(([v]) => v)
+        .sort((a, b) => (esMasNueva(a, b) ? -1 : 1));
+    const version = validas[0];
+    if (version) {
+        e.candidatas[version].intentos++;
+        cambios = true;
+    }
+    if (cambios)
+        guardarEstado(e, dir);
+    return { elegida: version ? { version, cli: rutaDeLaVersion(version, dir).cli } : null, retirada };
+}
+export function confirmarArranque(opts = {}) {
+    const env = opts.env ?? process.env;
+    const desde = env.PARX_LANZADO_DESDE ?? '';
+    if (!partes(desde))
+        return null;
+    const dir = opts.dir ?? carpetaDeConfiguracion();
+    const actual = opts.actual ?? VERSION;
+    const e = leerEstado(dir);
+    const c = e.candidatas[actual];
+    if (!c)
+        return null;
+    const primera = !c.anunciada;
+    c.arranca = true;
+    c.intentos = 0;
+    c.anunciada = true;
+    guardarEstado(e, dir);
+    return primera ? { version: actual, novedad: c.novedad ?? null } : null;
+}
+export async function lanzarLaMasNueva(opts = {}) {
+    const env = opts.env ?? process.env;
+    if (env.PARX_LANZADO_DESDE)
+        return { lanzada: false, retirada: null };
+    if (autoactualizarApagada(env, opts.ajustes ?? leerAjustes(opts.dir)))
+        return { lanzada: false, retirada: null };
+    const gestor = opts.gestor ?? ordenDeActualizar(rutaDelCli()).gestor;
+    if (!gestorPermiteAutoactualizar(gestor))
+        return { lanzada: false, retirada: null };
+    let retirada = null;
+    for (let intento = 0; intento < 3; intento++) {
+        const eleccion = elegirVersionParaArrancar({ dir: opts.dir, actual: opts.actual });
+        retirada = eleccion.retirada ?? retirada;
+        if (!eleccion.elegida)
+            return { lanzada: false, retirada };
+        env.PARX_LANZADO_DESDE = opts.actual ?? VERSION;
+        try {
+            await (opts.importar ?? ((u) => import(__rewriteRelativeImportExtension(u))))(pathToFileURL(eleccion.elegida.cli).href);
+            return { lanzada: true, version: eleccion.elegida.version };
+        }
+        catch (e) {
+            delete env.PARX_LANZADO_DESDE;
+            marcarMala(eleccion.elegida.version, `import: ${e instanceof Error ? e.message.slice(0, 200) : String(e)}`, opts.dir);
+            retirada = eleccion.elegida.version;
+        }
+    }
+    return { lanzada: false, retirada };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getparallel/parx",
-  "version": "0.5.0",
+  "version": "0.6.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",