@getparallel/parx 0.5.0 → 0.7.0

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/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.5.0",
+  "version": "0.7.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",