@getparallel/parx 0.0.0-stage → 0.4.1

package/dist/config.js

@@ -0,0 +1,112 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function carpetaDeConfiguracion(env = process.env, plataforma = process.platform) {
+    if (env.PARX_HOME)
+        return env.PARX_HOME;
+    if (env.PARALLEL_CODE_HOME)
+        return env.PARALLEL_CODE_HOME;
+    return join(baseDeConfiguracion(env, plataforma), 'parx');
+}
+function baseDeConfiguracion(env, plataforma) {
+    if (plataforma === 'win32')
+        return env.APPDATA ?? join(homedir(), 'AppData', 'Roaming');
+    return env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+}
+export function migrarCarpetaVieja(env = process.env, plataforma = process.platform) {
+    if (env.PARX_HOME || env.PARALLEL_CODE_HOME)
+        return;
+    const vieja = join(baseDeConfiguracion(env, plataforma), 'parallel-code');
+    const nueva = carpetaDeConfiguracion(env, plataforma);
+    try {
+        if (existsSync(vieja) && !existsSync(nueva))
+            renameSync(vieja, nueva);
+    }
+    catch {
+    }
+}
+export const VERSION = leerVersion();
+function leerVersion() {
+    try {
+        const v = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+        return typeof v === 'string' ? v : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const NOMBRE = 'parx';
+export function urlDelServidor(env = process.env) {
+    return (env.PARALLEL_URL ?? 'https://getparallel.net').replace(/\/+$/, '');
+}
+export const FORMA_TOKEN = /^par_term_[A-Za-z0-9_-]{40}$/;
+export const FORMA_CLAVE = /^par_key_[A-Za-z0-9_-]{40}$/;
+export function esCredencial(x) {
+    return typeof x === 'string' && (FORMA_TOKEN.test(x) || FORMA_CLAVE.test(x));
+}
+export function credencialesDelEntorno(env = process.env) {
+    const clave = (env.PARALLEL_API_KEY ?? env.PARX_API_KEY ?? '').trim();
+    if (!clave)
+        return null;
+    if (!FORMA_CLAVE.test(clave))
+        return null;
+    return { token: clave, correo: '', servidor: urlDelServidor(env), creadas: '', tipo: 'entorno' };
+}
+const MODELO_VIEJO = { rapido: 'swift', potente: 'stride', maximo: 'summit', swift: 'swift', stride: 'stride', summit: 'summit' };
+const MODO_VIEJO = { preguntar: 'ask', ask: 'ask', auto: 'auto', leer: 'read', read: 'read' };
+function asegurarCarpeta(dir) {
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+}
+export function leerCredenciales(dir = carpetaDeConfiguracion()) {
+    try {
+        const c = JSON.parse(readFileSync(join(dir, 'credenciales.json'), 'utf8'));
+        if (esCredencial(c.token) && typeof c.servidor === 'string') {
+            return { token: c.token, correo: String(c.correo ?? ''), servidor: c.servidor, creadas: String(c.creadas ?? ''), tipo: FORMA_CLAVE.test(c.token) ? 'clave' : 'navegador' };
+        }
+    }
+    catch {
+    }
+    return null;
+}
+export function guardarCredenciales(c, dir = carpetaDeConfiguracion()) {
+    asegurarCarpeta(dir);
+    const ruta = join(dir, 'credenciales.json');
+    writeFileSync(ruta, JSON.stringify(c, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(ruta, 0o600);
+    }
+    catch {
+    }
+}
+export function borrarCredenciales(dir = carpetaDeConfiguracion()) {
+    rmSync(join(dir, 'credenciales.json'), { force: true });
+}
+export function leerAjustes(dir = carpetaDeConfiguracion()) {
+    try {
+        const a = JSON.parse(readFileSync(join(dir, 'ajustes.json'), 'utf8'));
+        const out = {};
+        if (typeof a.modelo === 'string' && MODELO_VIEJO[a.modelo])
+            out.modelo = MODELO_VIEJO[a.modelo];
+        if (typeof a.modo === 'string' && MODO_VIEJO[a.modo])
+            out.modo = MODO_VIEJO[a.modo];
+        if (typeof a.avisos === 'boolean')
+            out.avisos = a.avisos;
+        const k = a.consejos;
+        if (k && typeof k === 'object') {
+            const n = (x) => (typeof x === 'number' && Number.isFinite(x) && x >= 0 ? Math.floor(x) : 0);
+            out.consejos = { sesiones: n(k.sesiones), siguiente: n(k.siguiente), ...(k.apagados === true ? { apagados: true } : {}) };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+export function guardarAjustes(cambios, dir = carpetaDeConfiguracion()) {
+    asegurarCarpeta(dir);
+    const a = { ...leerAjustes(dir), ...cambios };
+    if (a.modo === 'bypass')
+        delete a.modo;
+    writeFileSync(join(dir, 'ajustes.json'), JSON.stringify(a, null, 2), { mode: 0o600 });
+}

package/dist/consejos.js

@@ -0,0 +1,54 @@
+import { capacidades } from "./marca.js";
+import { t } from "./textos.js";
+export const CONSEJOS = ['menu', 'modo', 'una', 'imagen', 'historial', 'pegar', 'deshacer', 'modelo', 'carriles', 'parar', 'cola', 'informe', 'mision', 'ensenar', 'saldo', 'cuenta', 'agents'];
+export function consejo(id) {
+    const u = capacidades().unicode;
+    const tecla = {
+        menu: '/',
+        modo: u ? '⇧⇥' : 'Shift+Tab',
+        una: 'parx "task"',
+        historial: u ? '↑ ↓' : 'Up/Down',
+        pegar: 'Paste',
+        imagen: 'Drag image',
+        deshacer: '/undo',
+        modelo: '/model',
+        parar: 'Esc',
+        cola: 'Enter',
+        carriles: 'parx --lanes',
+        informe: '/report',
+        mision: '/mission',
+        ensenar: '/teach',
+        saldo: '/balance',
+        cuenta: 'parx account',
+        agents: 'AGENTS.md',
+    };
+    return { tecla: tecla[id], texto: t(`tip.${id}`) };
+}
+export function cuantosTocan(n) {
+    if (n <= 3)
+        return 3;
+    if (n <= 6)
+        return 2;
+    if (n <= 12)
+        return 1;
+    return 0;
+}
+export function elegirConsejos(estado) {
+    const e = estado ? { ...estado } : { sesiones: 0, siguiente: 0 };
+    if (e.apagados)
+        return { ids: [], estado: e };
+    const sesion = e.sesiones + 1;
+    const n = cuantosTocan(sesion);
+    const desde = ((e.siguiente % CONSEJOS.length) + CONSEJOS.length) % CONSEJOS.length;
+    const ids = Array.from({ length: n }, (_, i) => CONSEJOS[(desde + i) % CONSEJOS.length]);
+    return { ids, estado: { ...e, sesiones: sesion, siguiente: (desde + n) % CONSEJOS.length } };
+}
+export function cambiarConsejos(estado, si) {
+    const e = estado ? { ...estado } : { sesiones: 0, siguiente: 0 };
+    if (si)
+        return { sesiones: 0, siguiente: e.siguiente };
+    return { ...e, apagados: true };
+}
+export function ordenDeConsejos(si) {
+    return `/tips ${si ? 'on' : 'off'}`;
+}

package/dist/cuenta.js

@@ -0,0 +1,261 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline/promises';
+import { borrarCredenciales, credencialesDelEntorno, FORMA_CLAVE, guardarCredenciales, leerCredenciales, urlDelServidor, } from "./config.js";
+import { cerrarSesion, correoVisible, ErrorDeParallel, quienEs, leerCuenta, pedirCodigo, recogerToken } from "./api.js";
+import { t } from "./textos.js";
+import { c, capacidades, sinColor } from "./marca.js";
+import { qrEnTexto } from "./qr.js";
+export function abrirNavegador(url) {
+    if (process.env.PARALLEL_NO_BROWSER)
+        return;
+    try {
+        const [programa, args] = process.platform === 'darwin'
+            ? ['open', [url]]
+            : process.platform === 'win32'
+                ? ['rundll32', ['url.dll,FileProtocolHandler', url]]
+                : ['xdg-open', [url]];
+        const hijo = spawn(programa, args, { stdio: 'ignore', detached: true, windowsHide: true });
+        hijo.on('error', () => { });
+        hijo.unref();
+    }
+    catch {
+    }
+}
+export function pareceSinNavegador(env = process.env, plataforma = process.platform) {
+    if (env.SSH_CONNECTION || env.SSH_CLIENT || env.SSH_TTY)
+        return true;
+    if (plataforma === 'linux' && !env.DISPLAY && !env.WAYLAND_DISPLAY)
+        return true;
+    return false;
+}
+export function formaDeLaOpcion(x) {
+    const v = x.trim().toLowerCase().replace(/^--/, '');
+    if (['1', 'navegador', 'browser', 'web', 'navigateur', 'browser-login'].includes(v))
+        return 'navegador';
+    if (['2', 'clave', 'api-key', 'apikey', 'key', 'with-api-key', 'chave', 'cle', 'clé', 'schlussel', 'schlüssel', 'chiave', 'sleutel'].includes(v))
+        return 'clave';
+    if (['3', 'sin-navegador', 'sin_navegador', 'no-browser', 'device', 'device-auth', 'dispositivo', 'ssh', 'sem-navegador', 'sans-navigateur', 'ohne-browser', 'senza-browser', 'zonder-browser'].includes(v))
+        return 'sin_navegador';
+    return null;
+}
+const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
+async function preguntarLinea(pregunta) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    try {
+        return await rl.question(pregunta);
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function elegirForma(escribir, tty) {
+    const ssh = pareceSinNavegador();
+    if (!tty)
+        return 'sin_navegador';
+    const filas = [
+        [t('entrar.navegador'), ssh ? '' : t('entrar.navegador_nota')],
+        [t('entrar.clave'), t('entrar.clave_nota')],
+        [t('entrar.sin_navegador'), ssh ? t('entrar.ssh_nota') : t('entrar.sin_navegador_nota')],
+    ];
+    const ancho = Math.max(...filas.map(([a]) => a.length)) + 3;
+    escribir(`  ${c.negrita(t('entrar.como'))}`);
+    escribir();
+    filas.forEach(([a, nota], i) => escribir(`  ${c.claro(String(i + 1))}  ${a.padEnd(ancho)}${c.gris(nota)}`));
+    escribir();
+    const porDefecto = ssh ? '3' : '1';
+    for (;;) {
+        const r = (await preguntarLinea(`  ${c.claro('›')} ${c.gris(`(${porDefecto}) `)}`)).trim();
+        const forma = formaDeLaOpcion(r || porDefecto);
+        if (forma)
+            return forma;
+        escribir(c.gris(`  ${t('entrar.elige')}`));
+    }
+}
+export async function leerOculto(pregunta, entrada = process.stdin, salida = process.stdout) {
+    if (!entrada.isTTY) {
+        let todo = '';
+        for await (const trozo of entrada)
+            todo += String(trozo);
+        return todo.split(/\r?\n/).find((l) => l.trim())?.trim() ?? '';
+    }
+    salida.write(pregunta);
+    return new Promise((resolver, rechazar) => {
+        let valor = '';
+        const fin = (e) => {
+            entrada.removeListener('data', alLeer);
+            try {
+                entrada.setRawMode(false);
+            }
+            catch {
+            }
+            entrada.pause();
+            salida.write('\n');
+            if (e)
+                rechazar(e);
+            else
+                resolver(valor.trim());
+        };
+        const alLeer = (trozo) => {
+            for (const ch of String(trozo)) {
+                if (ch === '\r' || ch === '\n')
+                    return fin();
+                if (ch === '\u0003')
+                    return fin(new ErrorDeParallel('interrumpido'));
+                if (ch === '\u007f' || ch === '\b')
+                    valor = valor.slice(0, -1);
+                else if (ch >= ' ')
+                    valor += ch;
+            }
+        };
+        entrada.setRawMode(true);
+        entrada.resume();
+        entrada.on('data', alLeer);
+    });
+}
+async function esperarAprobacion(servidor, d) {
+    const fin = Date.now() + d.caduca_en * 1000;
+    let intervalo = Math.max(2, d.intervalo) * 1000;
+    while (Date.now() < fin) {
+        await dormir(intervalo);
+        let r;
+        try {
+            r = await recogerToken(servidor, d.codigo_dispositivo);
+        }
+        catch (e) {
+            if (e instanceof ErrorDeParallel && e.codigo === 'red') {
+                intervalo = Math.min(intervalo * 2, 15_000);
+                continue;
+            }
+            throw e;
+        }
+        if (r.estado === 'aprobado')
+            return { token: r.token, correo: r.correo };
+        if (r.estado === 'rechazado')
+            throw new Error(t('cuenta.rechazado'));
+        if (r.estado === 'caducado')
+            break;
+    }
+    throw new Error(t('cuenta.caducado'));
+}
+async function conDispositivo(servidor, escribir, abrir) {
+    const d = await pedirCodigo(servidor);
+    escribir();
+    if (abrir) {
+        escribir(`  ${t('cuenta.abre')}:`);
+        escribir(`  ${c.marca(d.url)}`);
+        escribir();
+        escribir(`  ${t('cuenta.codigo')}:  ${c.negrita(c.claro(d.codigo_usuario))}`);
+        escribir();
+        escribir(c.gris(`  ${t('cuenta.abriendo')}`));
+        abrirNavegador(d.url_completa);
+    }
+    else {
+        escribir(`  ${t('entrar.abre_en_otro')}`);
+        escribir(`  ${c.marca(d.url_corta ?? d.url)}`);
+        escribir();
+        escribir(`  ${t('cuenta.codigo')}:  ${c.negrita(c.claro(d.codigo_usuario))}`);
+        const caps = capacidades();
+        const qr = qrEnTexto(d.url_corta_completa ?? d.url_completa, { color: caps.color > 0, unicode: caps.unicode });
+        if (qr && caps.ancho >= sinColor(qr[0]).length + 4) {
+            escribir();
+            escribir(c.gris(`  ${t('entrar.escanea')}`));
+            escribir();
+            for (const l of qr)
+                escribir(`  ${l}`);
+        }
+        escribir();
+    }
+    escribir(c.gris(`  ${t('cuenta.esperando')}`));
+    const r = await esperarAprobacion(servidor, d);
+    return { token: r.token, correo: r.correo, servidor, creadas: new Date().toISOString(), tipo: 'navegador' };
+}
+async function conClave(servidor, escribir, clavePasada) {
+    let clave = clavePasada;
+    if (!clave) {
+        if (process.stdin.isTTY) {
+            escribir(c.gris(`  ${t('entrar.crea_clave')}`));
+            escribir();
+        }
+        clave = await leerOculto(`  ${t('entrar.pega_clave')}: `);
+    }
+    if (!FORMA_CLAVE.test(clave))
+        throw new Error(t('entrar.clave_mala'));
+    let cuenta;
+    try {
+        cuenta = await leerCuenta(servidor, clave);
+    }
+    catch (e) {
+        if (e instanceof ErrorDeParallel && e.codigo === 'sesion')
+            throw new Error(t('entrar.clave_no_vale'));
+        throw e;
+    }
+    return { cred: { token: clave, correo: cuenta.correo, servidor, creadas: new Date().toISOString(), tipo: 'clave' }, cuenta };
+}
+export async function entrar(escribir, opciones = {}) {
+    const servidor = urlDelServidor();
+    const tty = opciones.tty ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const antes = leerCredenciales();
+    if (antes && tty) {
+        escribir(c.gris(`  ${t('entrar.ya', { correo: correoVisible(antes.correo) || '·' })}`));
+        escribir();
+    }
+    const forma = opciones.forma ?? (await elegirForma(escribir, tty));
+    let cred;
+    if (forma === 'clave') {
+        const r = await conClave(servidor, escribir);
+        cred = r.cred;
+        guardarCredenciales(cred);
+        escribir(`${c.ok('✓')} ${t('entrar.ok_clave', { correo: quienEs(r.cuenta) || '·', nombre: r.cuenta.nombre ?? '' })}`);
+    }
+    else {
+        cred = await conDispositivo(servidor, escribir, forma === 'navegador');
+        guardarCredenciales(cred);
+        escribir(`${c.ok('✓')} ${correoVisible(cred.correo) ? t('cuenta.ok', { correo: correoVisible(cred.correo) }) : t('entrar.ok_sin_correo')}`);
+    }
+    if (antes && antes.tipo === 'navegador' && antes.token !== cred.token) {
+        try {
+            await cerrarSesion(antes.servidor, antes.token);
+        }
+        catch {
+        }
+    }
+    return cred;
+}
+export function credencialesActivas() {
+    return credencialesDelEntorno() ?? leerCredenciales();
+}
+export async function salir(escribir, todas = false) {
+    const entorno = credencialesDelEntorno();
+    const cred = leerCredenciales();
+    const usar = cred ?? entorno;
+    if (todas && usar) {
+        const r = await cerrarSesion(usar.servidor, usar.token, true);
+        if (cred)
+            borrarCredenciales();
+        escribir(t('salir.todas', { n: r.cerradas ?? 0 }));
+        return;
+    }
+    if (cred) {
+        if (cred.tipo !== 'clave') {
+            try {
+                await cerrarSesion(cred.servidor, cred.token);
+            }
+            catch {
+            }
+        }
+        borrarCredenciales();
+        escribir(cred.tipo === 'clave' ? t('salir.clave') : t('cuenta.fuera'));
+    }
+    else if (!entorno) {
+        escribir(t('cuenta.fuera'));
+    }
+    if (entorno)
+        escribir(t('salir.entorno'));
+}
+export function comoHasEntrado(cred, cuenta, equipoLocal) {
+    if (cred.tipo === 'entorno')
+        return t('cuenta.via_entorno');
+    if (cuenta.via === 'clave' || cred.tipo === 'clave')
+        return t('cuenta.via_clave', { nombre: cuenta.nombre ?? '', prefijo: cuenta.prefijo ?? cred.token.slice(0, 12) });
+    return t('cuenta.via_navegador', { equipo: cuenta.nombre ?? equipoLocal });
+}

package/dist/diff.js

@@ -0,0 +1,80 @@
+export function diffDeLineas(antes, despues) {
+    const a = antes === '' ? [] : antes.split('\n');
+    const b = despues === '' ? [] : despues.split('\n');
+    let ini = 0;
+    while (ini < a.length && ini < b.length && a[ini] === b[ini])
+        ini++;
+    let finA = a.length;
+    let finB = b.length;
+    while (finA > ini && finB > ini && a[finA - 1] === b[finB - 1]) {
+        finA--;
+        finB--;
+    }
+    const ma = a.slice(ini, finA);
+    const mb = b.slice(ini, finB);
+    if (ma.length * mb.length > 4_000_000)
+        return null;
+    const n = ma.length;
+    const m = mb.length;
+    const dp = Array.from({ length: n + 1 }, () => new Uint32Array(m + 1));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            dp[i][j] = ma[i] === mb[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    for (let k = 0; k < ini; k++)
+        out.push({ tipo: ' ', texto: a[k], antes: k + 1, despues: k + 1 });
+    let i = 0;
+    let j = 0;
+    while (i < n || j < m) {
+        if (i < n && j < m && ma[i] === mb[j]) {
+            out.push({ tipo: ' ', texto: ma[i], antes: ini + i + 1, despues: ini + j + 1 });
+            i++;
+            j++;
+        }
+        else if (i < n && (j >= m || dp[i + 1][j] >= dp[i][j + 1])) {
+            out.push({ tipo: '-', texto: ma[i], antes: ini + i + 1, despues: null });
+            i++;
+        }
+        else {
+            out.push({ tipo: '+', texto: mb[j], antes: null, despues: ini + j + 1 });
+            j++;
+        }
+    }
+    for (let k = 0; k < a.length - finA; k++)
+        out.push({ tipo: ' ', texto: a[finA + k], antes: finA + k + 1, despues: finB + k + 1 });
+    return out;
+}
+export function trozos(lineas, contexto = 2) {
+    const mostrar = new Array(lineas.length).fill(false);
+    lineas.forEach((l, i) => {
+        if (l.tipo !== ' ')
+            for (let k = Math.max(0, i - contexto); k <= Math.min(lineas.length - 1, i + contexto); k++)
+                mostrar[k] = true;
+    });
+    const out = [];
+    let saltado = false;
+    lineas.forEach((l, i) => {
+        if (mostrar[i]) {
+            if (saltado && out.length)
+                out.push(null);
+            saltado = false;
+            out.push(l);
+        }
+        else
+            saltado = true;
+    });
+    return out;
+}
+export function contarCambios(lineas) {
+    let mas = 0;
+    let menos = 0;
+    for (const l of lineas) {
+        if (l.tipo === '+')
+            mas++;
+        else if (l.tipo === '-')
+            menos++;
+    }
+    return { mas, menos };
+}