@getparallel/parx 0.5.0 → 0.7.0

package/dist/remoto.js

@@ -0,0 +1,295 @@
+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') {
+            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;
+            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/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/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 });
+    }
+}