@getparallel/parx 0.0.0-stage → 0.4.0

package/CHANGELOG.md

@@ -0,0 +1,28 @@
+# Changelog
+
+All notable changes to parx. Versions follow [semantic versioning](https://semver.org): every
+change that ships is a new version (patch by default; minor for new features; major for breaking
+changes). Entries are generated by `npm run release` from the git history of `apps/terminal`.
+
+<!-- Notes written under «## Unreleased» are used as the next entry instead of the git log. -->
+
+## 0.4.0 (2026-10-10)
+
+- Published on npm as `@getparallel/parx` (install with `npm install -g @getparallel/parx`). The command is still `parx`.
+- English only. Modes Ask (default), Auto, Read only and Bypass (only when you turn it on, with a confirmation; credentials always ask).
+- Models Swift 1.0, Stride 1.0 (default) and Summit 1.0.
+- Live Actions and time while it works, new rail animations, simpler screen.
+- `/mission`, `--lanes`, `/teach`, `/report`, images in a task, desktop notifications.
+- Welcome and tips at the top, input at the bottom.
+
+## 0.3.0 (2026-10-10)
+
+- Its own screen: rails, input anchored at the bottom, `/` menu with filter, resizes live at any width.
+
+## 0.2.0 (2026-10-10)
+
+- Renamed from Parallel Code to parx. Three ways to sign in (browser, API key, no browser with a QR), connected terminals, `parx account`, `parx logout --all`.
+
+## 0.1.0 (2026-10-10)
+
+- First version: the coding agent of Parallel in the terminal.

package/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2026 Parallel / Gonzalo Sánchez-Cervera. All rights reserved.
+
+parx is proprietary software. You may install and run it only to use it with a Parallel account
+(https://getparallel.net), subject to the Parallel Terms of Service (https://getparallel.net/terms).
+
+You may not copy, modify, adapt, translate, reverse engineer, redistribute, sublicense, rent or
+sell parx or its source code, in whole or in part, without prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. TO THE EXTENT PERMITTED BY LAW, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY ARISING FROM THE USE OF THE SOFTWARE.

package/README.md

@@ -1,3 +1,139 @@
-# Temporary Holding Version
+# parx
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The coding agent of [Parallel](https://getparallel.net), in your terminal. It reads and edits your
+project, runs commands and tests, and does coding tasks end to end. Mac, Windows (PowerShell and
+cmd) and Linux. English only. Formerly *Parallel Code*: the `parallel-code` and `pcode` commands
+still work for now and tell you about the new name.
+
+## Install
+
+You need [Node.js](https://nodejs.org) 20 or newer.
+
+```sh
+# macOS and Linux
+curl -fsSL https://getparallel.net/install | sh
+
+# Windows (PowerShell)
+irm https://getparallel.net/install.ps1 | iex
+
+# or directly with npm (any system)
+npm install -g @getparallel/parx
+```
+
+Then:
+
+```sh
+cd my-project
+parx                               # interactive session
+parx "fix the failing tests"       # one task and exit
+parx --lanes "fix login" "add tests" "update README"   # 2 or 3 tasks at once
+```
+
+You need a [Parallel](https://getparallel.net) account: each task is charged in Parallel Actions.
+
+## Updates
+
+parx checks npm for a new version at most once a day, in the background and with a short timeout
+(it never slows anything down), and shows one discreet line when there is one,
+«parx 0.4.2 available · run `parx update`». `parx update` runs the right command for how you
+installed it (npm, pnpm, bun, yarn or Homebrew). Set `PARX_NO_UPDATE_CHECK=1` (or
+`NO_UPDATE_NOTIFIER=1`) to turn the check off; it is also off in CI.
+
+Every change ships as a new version ([semver](https://semver.org)); see the
+[changelog](https://www.npmjs.com/package/@getparallel/parx?activeTab=code) (`CHANGELOG.md` in the package).
+
+## Signing in
+
+`parx login` (or the first run) asks how:
+
+1. **In the browser** (recommended). parx opens getparallel.net with a one-time code; you approve it
+   and the terminal gets its own token (stored with 0600 permissions in `~/.config/parx`, or
+   `%APPDATA%\parx` on Windows).
+2. **With an API key.** Create a key in getparallel.net → Settings → parx → API keys (shown once),
+   then paste it (hidden input) or pipe it: `echo "$KEY" | parx login --api-key`. Or set
+   `PARALLEL_API_KEY=par_key_…` and nothing is stored on disk (CI, servers).
+3. **No browser on this machine** (SSH). parx shows a short link (`getparallel.net/code`), the code
+   and a QR to open it on your phone.
+
+`parx account` says who you are, your plan, your Actions and how you signed in. `parx logout` signs
+out here; `parx logout --all` signs out every terminal.
+
+## Models
+
+**Swift 1.0** (fast, spends less), **Stride 1.0** (the default) and **Summit 1.0** (most capable,
+spends more). `/model swift|stride|summit` or `--model`. Each task is charged in Parallel Actions,
+once per task; while it works you see the Actions and the time of the task live, and the total when
+you leave.
+
+## Modes and safety
+
+parx can read, write and run anywhere on your computer with your own permissions. The mode decides
+when it asks first:
+
+| Mode | Inside the project and allowed folders | Outside |
+| --- | --- | --- |
+| **Ask** (default) | reads freely; asks before every change and every command | asks the first time per folder |
+| **Auto** | no questions (risky commands like `git push`, `sudo`, deploys still ask) | asks the first time per folder |
+| **Read only** | only reads | asks the first time per folder |
+| **Bypass** | no questions anywhere | no questions |
+
+- **Bypass** is never the default and never saved: turn it on yourself with `--bypass`, or with
+  `/mode bypass`, a clear warning and typing `bypass` to confirm. The status line shows `▲ Bypass` in
+  amber while it is on. Shift+Tab (Ask → Auto → Read only) leaves it.
+- **Credentials always ask**, in every mode including Bypass: `.env` files, SSH keys, `~/.aws`,
+  `.npmrc`, keychains, tokens. Each time it needs an explicit «Yes, this once» (No comes selected).
+  Their paths, commands and contents never go to the log, and commands run with secret-looking
+  environment variables removed.
+- **More folders:** `/folder <path>` or `--add-folder <path>` lets parx work there like in the project.
+- **Sandbox (optional):** `--sandbox` runs commands, on macOS, in a `sandbox-exec` jail that only
+  allows writing inside the project, the allowed folders and temp/cache folders.
+- **Log:** paths, commands, decisions and Actions (never file contents or keys) go to
+  `~/.config/parx/registro/YYYY-MM-DD.jsonl`. `/undo` reverts the last file change.
+
+## Inside a session
+
+The input sits at the bottom from the start; the status lives in one place, the row under the rail:
+the mode and the model at rest; while it works, what it is doing in plain words («Reading 3 files»,
+«Running tests», or «Tracing the route…» while it plans), the time and the Actions so far, with a
+small rail animation (a dot along the route, a train on the track, a sleeper scanning the rails, the
+track being laid).
+
+Type `/` for the commands; the menu filters as you type, ↑ ↓ move, Tab or Enter pick, Esc closes.
+
+| Command | What it does |
+| --- | --- |
+| `/mode` | Ask, Auto, Read only or Bypass |
+| `/model` | Swift, Stride or Summit |
+| `/folder <path>` | let parx work in another folder |
+| `/lanes` | 2 or 3 tasks at once, each in its own lane, all moving together |
+| `/mission [goal]` | turn the work into a Parallel mission that keeps running on Parallel’s servers after you close the terminal; phone notification when it is done |
+| `/report` | a plain-language summary of what was done, copied to the clipboard for an email or WhatsApp |
+| `/teach` | class mode: explains each step as it codes, like a teacher |
+| `/undo`, `/new`, `/balance`, `/log`, `/help`, `/exit` | the usual |
+| `/notify` on, off | desktop notifications |
+| `/tips` on, off | the welcome tips |
+
+**Images:** drag a screenshot into the window (or paste its path) and it becomes a chip
+(`[Image · error.png]`); parx sends it with the task to understand the error or the design. PNG,
+JPEG, GIF or WebP; big ones are shrunk on macOS.
+
+**Par notifies you:** if you switch to another window while parx works, a desktop notification (macOS,
+Windows, Linux) with the Parallel sound tells you when it finishes or needs you. Terminals that do
+not report focus get it only for tasks longer than 45 s. `/notify off` turns it off.
+
+**A mission** does not touch the files on your computer: it researches, writes and uses your
+connected apps on Parallel. It launches by itself when its plan is ready, with every action that goes
+outside still asking for your approval in Parallel.
+
+Shift+Tab cycles the mode. ↑ ↓ walk the history. A long paste becomes one chip. While it works you can
+type the next task: Enter queues it. Esc or Ctrl+C stops a task; Ctrl+C twice on an empty input
+exits; Ctrl+L redraws. Resizing the window recomposes the conversation at the new width (40 to 200+
+columns). `NO_COLOR` and `--ascii` are respected.
+
+Projects can add an `AGENTS.md` (or `PARALLEL.md`) with instructions for the agent. The agent
+answers in the language you write in.
+
+## License
+
+Proprietary. © 2026 Parallel / Gonzalo Sánchez-Cervera. All rights reserved. See `LICENSE`. Use is subject to the
+[Parallel Terms of Service](https://getparallel.net/terms).

package/dist/actualizar.js

@@ -0,0 +1,112 @@
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { carpetaDeConfiguracion, VERSION } from "./config.js";
+export const PAQUETE = '@getparallel/parx';
+export const PAQUETE_EN_URL = PAQUETE.replace('/', '%2f');
+export const UN_DIA_MS = 24 * 60 * 60 * 1000;
+const PLAZO_MS = 2500;
+const FICHERO = 'actualizacion.json';
+export function comprobacionApagada(env = process.env) {
+    const si = (x) => Boolean(x && x !== '0' && x.toLowerCase() !== 'false');
+    return si(env.PARX_NO_UPDATE_CHECK) || si(env.NO_UPDATE_NOTIFIER) || si(env.CI) || si(env.PARX_PRUEBAS);
+}
+export function partes(v) {
+    const m = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(v.trim());
+    return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
+}
+export function esMasNueva(a, b) {
+    const x = partes(a);
+    const y = partes(b);
+    if (!x || !y)
+        return false;
+    for (let i = 0; i < 3; i++)
+        if (x[i] !== y[i])
+            return x[i] > y[i];
+    return false;
+}
+function leerEstado(dir) {
+    try {
+        const e = JSON.parse(readFileSync(join(dir, FICHERO), 'utf8'));
+        if (typeof e.comprobada === 'string' && typeof e.ultima === 'string')
+            return { comprobada: e.comprobada, ultima: e.ultima };
+    }
+    catch {
+    }
+    return null;
+}
+function guardarEstado(dir, e) {
+    try {
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(join(dir, FICHERO), JSON.stringify(e, null, 2), { mode: 0o600 });
+    }
+    catch {
+    }
+}
+export function versionNuevaConocida(opts = {}) {
+    if (comprobacionApagada(opts.env))
+        return null;
+    const e = leerEstado(opts.dir ?? carpetaDeConfiguracion());
+    return e && esMasNueva(e.ultima, opts.actual ?? VERSION) ? e.ultima : null;
+}
+export async function ultimaPublicada(opts = {}) {
+    const registro = (opts.registro ?? process.env.PARX_REGISTRY ?? 'https://registry.npmjs.org').replace(/\/+$/, '');
+    try {
+        const r = await (opts.fetch ?? fetch)(`${registro}/${PAQUETE_EN_URL}/latest`, {
+            headers: { accept: 'application/json', 'user-agent': `parx/${VERSION}` },
+            signal: AbortSignal.timeout(opts.plazoMs ?? PLAZO_MS),
+        });
+        if (!r.ok)
+            return null;
+        const v = (await r.json()).version;
+        return typeof v === 'string' && partes(v) ? v : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function comprobarDeFondo(opts = {}) {
+    if (comprobacionApagada(opts.env))
+        return null;
+    const dir = opts.dir ?? carpetaDeConfiguracion();
+    const ahora = opts.ahora ?? Date.now();
+    const e = leerEstado(dir);
+    const hace = e ? ahora - Date.parse(e.comprobada) : Infinity;
+    if (e && hace >= 0 && hace < UN_DIA_MS)
+        return esMasNueva(e.ultima, opts.actual ?? VERSION) ? e.ultima : null;
+    const ultima = await ultimaPublicada(opts);
+    guardarEstado(dir, { comprobada: new Date(ahora).toISOString(), ultima: ultima ?? e?.ultima ?? opts.actual ?? VERSION });
+    return ultima && esMasNueva(ultima, opts.actual ?? VERSION) ? ultima : null;
+}
+export function lineaDeVersionNueva(v) {
+    return `parx ${v} available — run \`parx update\``;
+}
+const ULTIMA = `${PAQUETE}@latest`;
+export function ordenDeActualizar(rutaCli, plataforma = process.platform) {
+    const r = rutaCli.replace(/\\/g, '/');
+    if (/\/Cellar\/parx\//.test(r) || /\/homebrew\/.*\/parx\//i.test(r))
+        return { gestor: 'brew', orden: ['brew', 'upgrade', 'parx'] };
+    if (/\/_npx\//.test(r))
+        return { gestor: 'npx', orden: null };
+    if (/\/\.bun\/install\/global\//.test(r))
+        return { gestor: 'bun', orden: ['bun', 'add', '-g', ULTIMA] };
+    if (/\/pnpm\/(global|.*\/global)\//i.test(r) || /\/\.pnpm\//.test(r))
+        return { gestor: 'pnpm', orden: ['pnpm', 'add', '-g', ULTIMA] };
+    if (/\/yarn\/global\//i.test(r) || /\/\.yarn\//.test(r) || /\/Yarn\/Data\/global\//i.test(r))
+        return { gestor: 'yarn', orden: ['yarn', 'global', 'add', ULTIMA] };
+    const npm = /^(.*)\/lib\/node_modules\/(?:@getparallel\/)?parx\//.exec(r) ?? (plataforma === 'win32' ? /^(.*)\/node_modules\/(?:@getparallel\/)?parx\//.exec(r) : null);
+    if (npm) {
+        const prefijo = plataforma === 'win32' ? npm[1].replace(/\//g, '\\') : npm[1];
+        return { gestor: 'npm', orden: ['npm', 'install', '-g', ULTIMA, '--prefix', prefijo] };
+    }
+    return { gestor: 'desarrollo', orden: null };
+}
+export function rutaDelCli() {
+    const arg = process.argv[1] ?? '';
+    try {
+        return realpathSync(arg);
+    }
+    catch {
+        return arg;
+    }
+}

package/dist/agente.js

@@ -0,0 +1,231 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { join } from 'node:path';
+import { ErrorDeParallel, turno } from "./api.js";
+import { DEFINICIONES, ejecutarHerramienta, etiquetaDeTanda } from "./herramientas.js";
+import { t } from "./textos.js";
+import { c, sep as separador } from "./marca.js";
+import { descripcionDelSistema, esRepoGit } from "./shell.js";
+import { MODELOS } from "./modelos.js";
+import { acciones as textoDeAcciones, duracion } from "./tui.js";
+const MAX_VUELTAS = 80;
+const MAX_CARACTERES_DE_CONTEXTO = 900_000;
+function notasDelProyecto(raiz) {
+    for (const nombre of ['PARALLEL.md', 'AGENTS.md']) {
+        const ruta = join(raiz, nombre);
+        if (existsSync(ruta)) {
+            try {
+                return `\n\n# Project notes (${nombre})\n${readFileSync(ruta, 'utf8').slice(0, 12_000)}`;
+            }
+            catch {
+            }
+        }
+    }
+    return '';
+}
+const PERMISOS = {
+    ask: 'Ask: the user approves every file change and every command. Reading inside the project and the allowed folders is free.',
+    auto: 'Auto: changes and normal commands inside the project and the allowed folders run without asking; risky commands and anything outside still need the user.',
+    read: 'Read only: you can read and search, but you cannot write files or run commands. Explain what you would change instead.',
+    bypass: 'Bypass: the user turned off the questions for this session; you can work anywhere on this computer. Be careful and do only what the task needs.',
+};
+export function instrucciones(raiz, modo, o = {}) {
+    const carpetas = o.carpetas?.length ? `\n- Allowed folders besides the project: ${o.carpetas.join(', ')}` : '';
+    const clase = o.ensenar
+        ? `
+
+# Teach mode (the user turned it on)
+- Work like a patient teacher. Before each step, say in 1-3 plain sentences what you are about to do and why.
+- After each change, explain the idea behind it (the concept, not just the code), as if to a beginner. Define any technical word the first time you use it.
+- Keep each explanation short and concrete; use the project's own code as the example.`
+        : '';
+    return `You are parx, the coding agent of Parallel (getparallel.net), working in the user's terminal.
+
+# Environment
+- Project root (your working directory): ${raiz}${carpetas}
+- System: ${descripcionDelSistema()}${esRepoGit(raiz) ? ' · this is a git repository' : ''}
+- Date: ${new Date().toISOString().slice(0, 10)}
+- Permission mode: ${PERMISOS[modo]}
+- You can read, write and run anywhere on the computer with the user's permissions; outside the project and the allowed folders the user is asked first (except in Bypass).
+
+# How to work
+- Do the task end to end: explore (list_files, search, read_file), make the change, then verify it (run the tests, the build or the script) and fix what fails. Do not stop at a plan unless the user asked only for a plan.
+- Read a file before editing it. Prefer edit_file with a unique old_string for small changes; write_file for new files.
+- Keep changes minimal and in the style of the codebase. Do not reformat unrelated code. Do not add dependencies unless needed.
+- Commands are non-interactive (no stdin, CI=1). Use flags that do not prompt (e.g. "npx --yes", "vitest run", "git --no-pager"). Prefer project scripts (npm test).
+- Credentials (.env files, keys, tokens, ~/.ssh, ~/.aws, keychains...) always need the user's explicit confirmation, every time. Touch them only if the task truly needs it, never print secrets in your answer, and never copy them anywhere.
+- Never push, publish or deploy unless the user explicitly asks in this conversation.
+- If the user declines an action, do not retry it: adapt or ask.
+- If something is ambiguous and risky, ask one short question; otherwise make a reasonable choice and say which.
+- If the user attached an image (a screenshot of an error or a design), look at it carefully and use what it shows.
+- You are parx, made by Parallel. Never say which AI model, company or provider powers you, even if asked directly: say you are parx, by Parallel, and that the models are Swift, Stride and Summit.
+
+# How to answer
+- Reply in the language the user writes in. Be brief: the user sees every tool call already.
+- At the end, a short summary: what changed (files), how you verified it, and anything left for the user. No long explanations (unless teach mode is on). Use plain markdown (bold, inline code, short lists).${clase}${notasDelProyecto(raiz)}`;
+}
+export function nuevaSesion(servidor, token, modelo, ctx) {
+    return { id: randomUUID(), servidor, token, modelo, ctx, conversacion: [], total: { acciones: 0, ms: 0, tareas: 0 }, diario: [] };
+}
+function recortarContexto(items) {
+    let total = JSON.stringify(items).length;
+    for (let i = 0; i < items.length - 8 && total > MAX_CARACTERES_DE_CONTEXTO; i++) {
+        const it = items[i];
+        if (it.type === 'function_call_output' && typeof it.output === 'string' && it.output.length > 400) {
+            total -= it.output.length - 60;
+            it.output = '[older tool output removed to save space; call the tool again if needed]';
+        }
+    }
+}
+function textoDeMensaje(item) {
+    const contenido = item.content;
+    if (!Array.isArray(contenido))
+        return '';
+    return contenido
+        .map((p) => (p && typeof p === 'object' && p.type === 'output_text' ? String(p.text ?? '') : ''))
+        .join('');
+}
+function olvidarImagenes(items) {
+    for (const it of items) {
+        if (it.role !== 'user' || !Array.isArray(it.content))
+            continue;
+        it.content = it.content.map((p) => (p.type === 'input_image' ? { type: 'input_text', text: '(the image above was shown earlier and removed to save space)' } : p));
+    }
+}
+export async function hacerTarea(s, pedido, señal, imagenes = []) {
+    const tarea = randomUUID();
+    const inicio = Date.now();
+    const { pantalla, registro } = s.ctx;
+    s.ctx.señal = señal;
+    s.ctx.hechos ??= { ficheros: [], comandos: [] };
+    const ficherosAntes = s.ctx.hechos.ficheros.length;
+    const comandosAntes = s.ctx.hechos.comandos.length;
+    s.conversacion.push(imagenes.length
+        ? {
+            role: 'user',
+            content: [
+                { type: 'input_text', text: pedido },
+                ...imagenes.flatMap((i) => [
+                    { type: 'input_text', text: `[image: ${i.nombre}]` },
+                    { type: 'input_image', image_url: i.dataUrl, detail: 'auto' },
+                ]),
+            ],
+        }
+        : { role: 'user', content: pedido });
+    registro.apuntar('tarea', { tarea, caracteres: pedido.length, imagenes: imagenes.length, modelo: s.modelo, modo: s.ctx.modo, ensenar: Boolean(s.ensenar) });
+    let acciones = 0;
+    let disponibles = null;
+    let respuesta = '';
+    let terminada = false;
+    const apuntarDiario = () => {
+        const h = s.ctx.hechos;
+        s.diario.push({
+            pedido: pedido.slice(0, 2000),
+            respuesta: respuesta.slice(0, 4000),
+            ficheros: h.ficheros.slice(ficherosAntes),
+            comandos: h.comandos.slice(comandosAntes),
+            acciones,
+            ms: Date.now() - inicio,
+            terminada,
+        });
+        s.total.acciones += acciones;
+        s.total.ms += Date.now() - inicio;
+        s.total.tareas++;
+    };
+    try {
+        for (let vuelta = 0; vuelta < MAX_VUELTAS; vuelta++) {
+            if (señal.aborted)
+                throw new ErrorDeParallel('interrumpido');
+            recortarContexto(s.conversacion);
+            pantalla.espera(null);
+            const r = await turno(s.servidor, s.token, {
+                modelo: MODELOS[s.modelo].servidor,
+                instrucciones: instrucciones(s.ctx.raiz, s.ctx.modo, { carpetas: s.ctx.carpetas, ensenar: s.ensenar }),
+                entrada: s.conversacion,
+                herramientas: [...DEFINICIONES],
+                tarea,
+                sesion: s.id,
+            }, señal);
+            acciones = r.acciones.tarea;
+            disponibles = r.acciones.disponibles;
+            pantalla.progreso(acciones);
+            registro.apuntar('turno', { tarea, vuelta, acciones });
+            const llamadas = [];
+            for (const item of r.salida) {
+                s.conversacion.push(item);
+                if (item.type === 'message') {
+                    const texto = textoDeMensaje(item).trim();
+                    if (texto) {
+                        respuesta = texto;
+                        pantalla.escribir();
+                        pantalla.texto(texto);
+                        pantalla.escribir();
+                    }
+                }
+                else if (item.type === 'function_call')
+                    llamadas.push(item);
+            }
+            if (!llamadas.length)
+                break;
+            const etiqueta = etiquetaDeTanda(llamadas.map((l) => ({ name: String(l.name ?? ''), arguments: String(l.arguments ?? '{}') })));
+            if (etiqueta)
+                pantalla.espera(etiqueta.texto, etiqueta.anim, false);
+            for (const ll of llamadas) {
+                if (señal.aborted)
+                    throw new ErrorDeParallel('interrumpido');
+                const salida = await ejecutarHerramienta(String(ll.name ?? ''), String(ll.arguments ?? '{}'), s.ctx);
+                s.conversacion.push({ type: 'function_call_output', call_id: ll.call_id, output: salida });
+            }
+        }
+        terminada = true;
+    }
+    catch (e) {
+        pantalla.pararEspera();
+        cerrarLlamadasPendientes(s.conversacion);
+        olvidarImagenes(s.conversacion);
+        apuntarDiario();
+        if (e instanceof ErrorDeParallel) {
+            registro.apuntar('error', { tarea, codigo: e.codigo, detalle: e.detalle.slice(0, 200) });
+            if (e.codigo === 'interrumpido') {
+                pantalla.escribir(c.gris(t('estado.interrumpido')));
+                return true;
+            }
+            pantalla.error(mensajeDeError(e));
+            return e.codigo !== 'sesion' && e.codigo !== 'sin_acceso';
+        }
+        throw e;
+    }
+    pantalla.pararEspera();
+    olvidarImagenes(s.conversacion);
+    const ms = Date.now() - inicio;
+    s.ultimaTarea = { acciones, ms };
+    s.disponibles = disponibles;
+    apuntarDiario();
+    registro.apuntar('tarea_hecha', { tarea, acciones, ms });
+    const sep = c.gris(separador());
+    pantalla.cierre(`${t('estado.hecho')}${sep}${c.gris(textoDeAcciones(acciones))}${sep}${c.gris(duracion(ms))}`);
+    return true;
+}
+function cerrarLlamadasPendientes(items) {
+    const respondidas = new Set(items.filter((i) => i.type === 'function_call_output').map((i) => i.call_id));
+    for (const i of [...items]) {
+        if (i.type === 'function_call' && !respondidas.has(i.call_id))
+            items.push({ type: 'function_call_output', call_id: i.call_id, output: 'Interrupted by the user before it ran.' });
+    }
+}
+export function mensajeDeError(e) {
+    switch (e.codigo) {
+        case 'sesion':
+            return t('error.sesion');
+        case 'sin_saldo':
+            return t('error.sin_saldo');
+        case 'sin_acceso':
+            return t('error.sin_acceso');
+        case 'demasiado':
+            return t('error.demasiado');
+        case 'red':
+            return t('error.red', { detalle: e.detalle });
+        default:
+            return t('error.servidor', { detalle: e.detalle || e.codigo });
+    }
+}

package/dist/api.js

@@ -0,0 +1,95 @@
+import { arch, hostname, platform, release } from 'node:os';
+import { VERSION } from "./config.js";
+export class ErrorDeParallel extends Error {
+    codigo;
+    detalle;
+    constructor(codigo, detalle = '') {
+        super(`${codigo}${detalle ? `: ${detalle}` : ''}`);
+        this.codigo = codigo;
+        this.detalle = detalle;
+    }
+}
+export function equipo() {
+    return { equipo: hostname().slice(0, 80), sistema: `${platform()} ${release()} ${arch()}`.slice(0, 80), version: VERSION };
+}
+async function llamar(servidor, ruta, init = {}) {
+    const control = new AbortController();
+    const reloj = setTimeout(() => control.abort(new Error('timeout')), init.plazoMs ?? 30_000);
+    const alAbortar = () => control.abort(new Error('interrumpido'));
+    init.señal?.addEventListener('abort', alAbortar, { once: true });
+    let r;
+    try {
+        r = await fetch(`${servidor}${ruta}`, {
+            method: init.metodo ?? (init.cuerpo === undefined ? 'GET' : 'POST'),
+            headers: {
+                'content-type': 'application/json',
+                'user-agent': `parx/${VERSION} (${platform()}; ${arch()})`,
+                ...(init.token ? { 'x-parallel-equipo': hostname().slice(0, 80) } : {}),
+                ...(init.token ? { authorization: `Bearer ${init.token}` } : {}),
+            },
+            body: init.cuerpo === undefined ? undefined : JSON.stringify(init.cuerpo),
+            signal: control.signal,
+        });
+    }
+    catch (e) {
+        if (init.señal?.aborted)
+            throw new ErrorDeParallel('interrumpido');
+        const causa = e instanceof Error ? (e.cause?.message ?? e.message) : String(e);
+        throw new ErrorDeParallel('red', causa);
+    }
+    finally {
+        clearTimeout(reloj);
+        init.señal?.removeEventListener('abort', alAbortar);
+    }
+    if (r.ok)
+        return (await r.json());
+    let error = '';
+    try {
+        error = String((await r.json()).error ?? '');
+    }
+    catch {
+    }
+    if (r.status === 401)
+        throw new ErrorDeParallel('sesion');
+    if (r.status === 402)
+        throw new ErrorDeParallel('sin_saldo');
+    if (r.status === 404)
+        throw new ErrorDeParallel('sin_acceso');
+    if (r.status === 503 && error === 'mantenimiento')
+        throw new ErrorDeParallel('servidor', 'mantenimiento');
+    if (r.status === 413)
+        throw new ErrorDeParallel('demasiado');
+    throw new ErrorDeParallel('servidor', `${r.status}${error ? ` ${error}` : ''}`);
+}
+export function pedirCodigo(servidor) {
+    return llamar(servidor, '/api/terminal/dispositivo', { cuerpo: equipo() });
+}
+export function recogerToken(servidor, codigoDispositivo) {
+    return llamar(servidor, '/api/terminal/token', { cuerpo: { codigo_dispositivo: codigoDispositivo } });
+}
+export function leerCuenta(servidor, token) {
+    return llamar(servidor, '/api/terminal/cuenta', { token });
+}
+export function cerrarSesion(servidor, token, todas = false) {
+    return llamar(servidor, `/api/terminal/cuenta${todas ? '?todas=1' : ''}`, { token, metodo: 'DELETE' });
+}
+export function turno(servidor, token, p, señal) {
+    return llamar(servidor, '/api/terminal/responses', { token, cuerpo: p, señal, plazoMs: 310_000 });
+}
+export function crearMision(servidor, token, objetivo, señal) {
+    return llamar(servidor, '/api/terminal/mision', { token, cuerpo: { objetivo }, señal, plazoMs: 60_000 });
+}
+export function verMision(servidor, token, generacion, señal) {
+    return llamar(servidor, `/api/terminal/mision?id=${encodeURIComponent(generacion)}`, { token, señal });
+}
+const CORREO_INTERNO = /@cuentas\.getparallel\.net$/i;
+export function correoVisible(correo) {
+    const c = (correo ?? '').trim();
+    return c && !CORREO_INTERNO.test(c) ? c : '';
+}
+export function quienEs(cu) {
+    const nombre = (cu?.persona ?? '').trim();
+    if (nombre && !CORREO_INTERNO.test(nombre))
+        return nombre;
+    return correoVisible(cu?.correo);
+}

package/dist/carriles.js

@@ -0,0 +1,44 @@
+import { hacerTarea, nuevaSesion } from "./agente.js";
+import { nuevoTrabajo } from "./tui.js";
+import { Pantalla } from "./ui.js";
+export const MAX_CARRILES = 3;
+export function pedidoDelCarril(i, tareas) {
+    const otras = tareas.filter((_, j) => j !== i);
+    return `[Lane ${i + 1} of ${tareas.length}. Other lanes are working at the same time in this project on: ${otras.map((o) => `"${o.replace(/\s+/g, ' ').slice(0, 160)}"`).join(', ')}. Stay on your own task, avoid editing the files they are likely to touch, and do not start long-running watchers or servers.]\n\n${tareas[i]}`;
+}
+export async function ejecutarCarriles(o) {
+    const tareas = o.tareas.slice(0, MAX_CARRILES);
+    const carriles = tareas.map((tarea, i) => ({ numero: i + 1, tarea, estado: 'trabaja', trabajo: nuevoTrabajo() }));
+    const sesiones = carriles.map((k) => {
+        const pantalla = new Pantalla(o.lectora, o.tty, k);
+        pantalla.fijarSuperficie(o.superficie);
+        const ctx = {
+            ...o.base,
+            pantalla,
+            hechos: { ficheros: [], comandos: [] },
+            carpetas: (o.base.carpetas ??= []),
+            lecturas: (o.base.lecturas ??= []),
+        };
+        const s = nuevaSesion(o.servidor, o.token, o.modelo, ctx);
+        s.ensenar = o.ensenar;
+        return s;
+    });
+    o.superficie?.fijarCarriles(carriles);
+    const resultados = await Promise.all(sesiones.map(async (s, i) => {
+        const k = carriles[i];
+        let ok = true;
+        try {
+            ok = await hacerTarea(s, pedidoDelCarril(i, tareas), o.señal);
+            const ultima = s.diario[s.diario.length - 1];
+            k.estado = o.señal.aborted || (ultima && !ultima.terminada) ? (ok ? 'parado' : 'error') : 'hecho';
+        }
+        catch {
+            ok = false;
+            k.estado = 'error';
+        }
+        k.hasta = Date.now();
+        o.superficie?.actualizarCarriles();
+        return ok;
+    }));
+    return { carriles, sesiones, ok: resultados.every(Boolean) };
+}