supcoflow 0.6.0 → 0.8.0

package/dist/comandos/proyecto-del-repo.js

@@ -15,7 +15,7 @@ export async function proyectoDelRepo(d, flags) {
     try {
         const proyecto = await d.buscarProyecto(d.api, leida.vigente.clave, repo);
         if (proyecto === null) {
-            const message = `El repo ${repo} todavía no tiene proyecto. Creá el proyecto: \`supcoflow proyecto crear\`.`;
+            const message = `The repo ${repo} doesn't have a project yet. Create the project: \`supcoflow project create\`.`;
             return { ok: false, resultado: { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "sin_proyecto", message, repo }, texto: message } };
         }
         return { ok: true, clave: leida.vigente.clave, proyecto };

package/dist/comandos/proyecto.js

@@ -52,7 +52,7 @@ function mismoArchivo(crudo, p) {
 }
 function resultadoDelProyecto(p, reusado, raiz, d) {
     const nuevo = { id: p.id, slug: p.slug, repo: p.repo };
-    const queda = reusado ? `El proyecto ${p.id} ya existía y lo reusé` : `Creé el proyecto ${p.id}`;
+    const queda = reusado ? `Project ${p.id} already existed and I reused it` : `I created project ${p.id}`;
     let archivo = null;
     if (raiz !== null) {
         archivo = path.join(raiz, ".supcoflow", "proyecto.json");
@@ -63,8 +63,8 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
             // decida. Su contenido NUNCA se copia a la salida (puede traer cualquier cosa, una clave
             // incluida, y `emitir` no sanea): sólo el id, si tiene forma de id.
             const idActual = idDelArchivo(actual);
-            const message = `Ya hay un \`.supcoflow/proyecto.json\` de otro proyecto (${idActual ?? "que no reconozco"}); no lo toqué. `
-                + `${queda} igual (${p.id}): si es el que querés, borrá el archivo y volvé a correr \`supcoflow proyecto crear\`.`;
+            const message = `There is already a \`.supcoflow/proyecto.json\` for another project (${idActual ?? "one I don't recognize"}); I didn't touch it. `
+                + `${queda} anyway: if that's the one you want, delete the file and run \`supcoflow project create\` again.`;
             return fallo(SALIDA.haceFaltaUnaPersona, "archivo_distinto", message, { archivo, id_actual: idActual, nuevo, reusado });
         }
         if (actual === null) {
@@ -72,7 +72,7 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
                 d.archivos.escribir(archivo, contenidoDelArchivo(p));
             }
             catch {
-                const message = `${queda} (${p.id}), pero no pude escribir ${archivo}. Volvé a correr \`supcoflow proyecto crear\`.`;
+                const message = `${queda}, but I couldn't write ${archivo}. Run \`supcoflow project create\` again.`;
                 return fallo(SALIDA.inesperado, "archivo_no_escrito", message, { archivo, nuevo, reusado });
             }
         }
@@ -80,7 +80,7 @@ function resultadoDelProyecto(p, reusado, raiz, d) {
     return {
         codigo: SALIDA.ok,
         json: { ok: true, proyecto: { id: p.id, slug: p.slug, repo: p.repo, rama: p.rama }, reusado, archivo },
-        texto: `${queda}: ${p.repo}, rama ${p.rama}.${archivo !== null ? ` Lo anoté en ${archivo}.` : ""}`,
+        texto: `${queda}: ${p.repo}, branch ${p.rama}.${archivo !== null ? ` Recorded in ${archivo}.` : ""}`,
     };
 }
 export async function proyectoCrear(d, flags) {
@@ -116,18 +116,18 @@ export async function proyectoCrear(d, flags) {
         if (flags.install !== null || flags.test !== null) {
             // Sin copiar los valores: son texto del usuario y el aviso sólo dice qué pasó con ellos. Callarlo
             // haría creer que el proyecto quedó con los comandos pedidos.
-            d.avisar("El proyecto ya existe: ignoré --install/--test. Para cambiar sus comandos hay que configurarlo.");
+            d.avisar("The project already exists: I ignored --install/--test. To change its commands, it has to be configured.");
         }
         return resultadoDelProyecto(existente, true, raiz, d);
     }
     if (conexion === null || conexion.estado !== "conectado") {
-        return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", "Conectá el repo primero: `supcoflow repo conectar`.", {
+        return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", "Connect the repo first: `supcoflow repo connect`.", {
             repo, ...(conexion !== null ? { estado: conexion.estado } : {}),
         });
     }
     if (flags.dryRun) {
         const haria = `POST /api/conexiones/${conexion.id}/proyecto`;
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, repo, haria }, texto: `Con --dry-run no hago nada; sin él, crearía el proyecto de ${repo} (${haria}).` };
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, repo, haria }, texto: `With --dry-run I do nothing; without it: create the project for ${repo} (${haria}).` };
     }
     const cuerpo = {};
     if (flags.install !== null)
@@ -153,27 +153,27 @@ export async function proyectoCrear(d, flags) {
             await d.idempotencia.olvidar(OPERACION, repo);
             const install = flags.install ?? "…";
             const test = flags.test ?? "…";
-            const message = `${alta.message || "Faltan comandos del proyecto."} Pasalos a mano: \`supcoflow proyecto crear --install ${comillas(install)} --test ${comillas(test)}\`.`;
+            const message = `${alta.message || "The project is missing commands."} Pass them yourself: \`supcoflow project create --install ${comillas(install)} --test ${comillas(test)}\`.`;
             return fallo(SALIDA.entradaInvalida, "comandos_faltantes", message, { faltantes: alta.faltantes });
         }
         case "no_conectada":
             await d.idempotencia.olvidar(OPERACION, repo);
-            return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", alta.message || "Conectá el repo primero: `supcoflow repo conectar`.", { repo });
+            return fallo(SALIDA.haceFaltaUnaPersona, "repo_sin_conectar", alta.message || "Connect the repo first: `supcoflow repo connect`.", { repo });
         case "en_curso":
             // Se conserva: el pedido en curso puede ser el nuestro y el reintento tiene que poder retomarlo.
-            return fallo(SALIDA.inesperado, "en_curso", "Otro pedido con esta clave está en curso; probá en un minuto.");
+            return fallo(SALIDA.inesperado, "en_curso", "Another request with this key is already in progress; try again in a minute.");
         case "clave_reusada":
             // No debería pasar (la clave es por repo y un reintento manda lo mismo); olvidarla deja reintentar limpio.
             await d.idempotencia.olvidar(OPERACION, repo);
-            return fallo(SALIDA.inesperado, "clave_reusada", "El motor rechazó la clave de idempotencia guardada; la descarté, probá de nuevo.");
+            return fallo(SALIDA.inesperado, "clave_reusada", "The engine rejected the saved idempotency key; I discarded it, try again.");
         case "rechazo": {
             // La clave se conserva: tras un rechazo el motor ya la soltó, y el próximo intento la reusa sin
             // chocar. Lo que cambia es el código: no todo rechazo es culpa de lo que se escribió.
-            const message = alta.message || "El motor rechazó el pedido.";
+            const message = alta.message || "The engine rejected the request.";
             if (RECHAZOS_DE_UNA_PERSONA.has(alta.error)) {
                 // Lo arregla alguien con permisos en GitHub (instalar la App, sumarle el repo): reintentar o
                 // cambiar flags no sirve, y un 3 haría que un asistente siguiera probando entradas.
-                return fallo(SALIDA.haceFaltaUnaPersona, alta.error, `${message} Revisá la instalación de la App en GitHub y volvé a conectar con \`supcoflow repo conectar\`.`);
+                return fallo(SALIDA.haceFaltaUnaPersona, alta.error, `${message} Check the App's installation on GitHub and connect again with \`supcoflow repo connect\`.`);
             }
             // Dos altas al mismo tiempo, o un proyecto borrado en el medio: el mismo pedido otra vez anda.
             if (RECHAZOS_TRANSITORIOS.has(alta.error))
@@ -197,14 +197,14 @@ export async function proyectoVer(d, flags) {
     try {
         const encontrado = await d.buscarProyecto(d.api, clave, repo);
         if (encontrado === null) {
-            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null }, texto: "Este repo todavía no tiene proyecto: `supcoflow proyecto crear`." };
+            return { codigo: SALIDA.ok, json: { ok: true, repo, proyecto: null }, texto: "This repo doesn't have a project yet: `supcoflow project create`." };
         }
         const { proyecto: p, github } = await d.leerProyecto(d.api, clave, encontrado.id);
         const proyecto = { id: p.id, slug: p.slug, repo: p.repo, rama: p.rama, install_command: p.installCommand, test_command: p.testCommand };
         return {
             codigo: SALIDA.ok,
             json: { ok: true, proyecto, github: { estado: github.estado, verificado_en: github.verificadoEn } },
-            texto: `${p.id} (${p.repo}, rama ${p.rama}): instala con \`${p.installCommand}\`, prueba con \`${p.testCommand}\`. GitHub: ${github.estado ?? "sin verificar"}.`,
+            texto: `${p.id} (${p.repo}, branch ${p.rama}): installs with \`${p.installCommand}\`, tests with \`${p.testCommand}\`. GitHub: ${github.estado ?? "not verified"}.`,
         };
     }
     catch (e) {

package/dist/comandos/quien-soy.js

@@ -1,4 +1,5 @@
 import { FalloDeLaTerminal, resultadoDeFallo, SALIDA } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { claveVigente } from "./clave-vigente.js";
 export async function comandoQuienSoy(d) {
     const origen = d.api.origin;
@@ -7,20 +8,20 @@ export async function comandoQuienSoy(d) {
         return leida.resultado;
     const vigente = leida.vigente;
     if (!vigente.completa) {
-        const otro = vigente.fuente === "archivo" ? "el llavero del sistema" : "el archivo de credenciales";
-        d.avisar(`Uso la clave de ${vigente.fuente}, pero no pude leer ${otro}: puede haber guardada otra más nueva.`);
+        const otro = vigente.fuente === "archivo" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
+        d.avisar(`I'm using the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]}, but I couldn't read ${otro}: a newer key may be saved there.`);
     }
     // Leer no cuesta nada y avisa de algo que la persona no vería de otro modo: claves viejas vivas.
     try {
         const { claves, completa } = await d.guardado.leerPorRevocar(origen);
         if (claves.length > 0) {
-            d.avisar(`Hay ${claves.length} clave(s) anterior(es) anotadas para revocar; se reintenta en el próximo login o logout.`);
+            d.avisar(`${claves.length} previous key(s) are noted down to be revoked; I'll try again on the next login or logout.`);
         }
         if (!completa)
-            d.avisar("No pude leer entera la lista de claves por revocar.");
+            d.avisar("I couldn't read the whole list of keys waiting to be revoked.");
     }
     catch {
-        d.avisar("No pude leer entera la lista de claves por revocar.");
+        d.avisar("I couldn't read the whole list of keys waiting to be revoked.");
     }
     let yo;
     try {
@@ -30,7 +31,7 @@ export async function comandoQuienSoy(d) {
         // Con la variable definida, «iniciá sesión de nuevo» no arregla nada: la variable sigue
         // ganándole a la clave nueva. Hay que decir cuál es la que no vale.
         if (e instanceof FalloDeLaTerminal && e.codigo === SALIDA.faltaLogin && vigente.fuente === "env") {
-            return resultadoDeFallo(new FalloDeLaTerminal(e.codigo, e.error, "La clave de SUPCOFLOW_TOKEN no vale: sacala de tu entorno o reemplazala por una vigente."));
+            return resultadoDeFallo(new FalloDeLaTerminal(e.codigo, e.error, "The key in SUPCOFLOW_TOKEN is not valid: remove it from your environment or replace it with a valid one."));
         }
         return resultadoDeFallo(e);
     }
@@ -38,6 +39,6 @@ export async function comandoQuienSoy(d) {
     return {
         codigo: SALIDA.ok,
         json: { ok: true, via: yo.via, equipo: yo.equipo, usuario: yo.usuario, proyecto: yo.proyecto, fuente: vigente.fuente },
-        texto: `${quien} en el equipo ${yo.equipo} (clave en ${vigente.fuente})`,
+        texto: `${quien} in team ${yo.equipo} (key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]})`,
     };
 }

package/dist/comandos/repo-conectar.js

@@ -17,22 +17,22 @@ function resultadoDelPedido(repo, p, avisar) {
             return {
                 codigo: SALIDA.ok,
                 json: { ok: true, estado: "conectado", repo, repo_canonico: p.repoCanonico, pedido },
-                texto: `${p.repoCanonico ?? repo} está conectado.`,
+                texto: `${p.repoCanonico ?? repo} is connected.`,
             };
         case "repo_fuera_de_alcance": {
-            const message = `La App está instalada pero no alcanza a ${repo}: sumalo en GitHub y volvé a tocar Confirmar (${p.url}).`;
+            const message = `The App is installed but doesn't have access to ${repo}: add it in GitHub and click Confirm again (${p.url}).`;
             return fallo(SALIDA.haceFaltaUnaPersona, "repo_fuera_de_alcance", message, { repo, url: p.url, pedido });
         }
         case "vencido":
-            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "El pedido venció. Pedí otro con `supcoflow repo conectar --start`.", { repo, pedido });
+            return fallo(SALIDA.haceFaltaUnaPersona, "pedido_vencido", "The request has expired. Ask for a new one with `supcoflow repo connect --start`.", { repo, pedido });
         case "pendiente": {
             // Un motivo anotado no cierra el pedido: la persona puede reintentar desde la misma página.
             if (p.fallo !== null)
-                avisar(`La última confirmación falló: ${p.fallo}.`);
+                avisar(`The last confirmation failed: ${p.fallo}.`);
             return {
                 codigo: SALIDA.esperandoAUnaPersona,
                 json: { ok: false, esperando: "persona", repo, url: p.url, pedido, ...(p.fallo !== null ? { fallo: p.fallo } : {}) },
-                texto: `Abrí ${p.url}, instalá la App en GitHub si hace falta y tocá Confirmar.`,
+                texto: `Open ${p.url}, install the App on GitHub if needed, and click Confirm.`,
             };
         }
     }
@@ -49,7 +49,7 @@ export async function repoConectarStart(d, flags) {
         return {
             codigo: SALIDA.ok,
             json: { ok: true, dry_run: true, repo, haria: "POST /api/conexiones" },
-            texto: `Con --dry-run no hago nada; sin él, pediría conectar ${repo} (POST /api/conexiones).`,
+            texto: `With --dry-run I do nothing; without it: ask to connect ${repo} (POST /api/conexiones).`,
         };
     }
     const leida = await claveVigente(d.guardado, d.api.origin);
@@ -92,7 +92,7 @@ export async function repoConectarWait(d, flags) {
             return resultadoDeFallo(e);
         }
         if (p === null) {
-            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `No hay una conexión en curso para ${repo}: empezá con \`supcoflow repo conectar --start\`.`, { repo });
+            return fallo(SALIDA.entradaInvalida, "sin_conexion_en_curso", `There is no connection in progress for ${repo}: start with \`supcoflow repo connect --start\`.`, { repo });
         }
         ultimo = p;
         if (p.estado !== "pendiente")
@@ -110,12 +110,12 @@ export async function repoConectarWait(d, flags) {
 // que nadie va a mirar.
 export async function repoConectarInteractivo(d, flags) {
     if (!d.esTty || flags.json) {
-        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Sin terminal interactiva usá `supcoflow repo conectar --start --json` y después `supcoflow repo conectar --wait --json`.");
+        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Without an interactive terminal, use `supcoflow repo connect --start --json` and then `supcoflow repo connect --wait --json`.");
     }
     const inicio = await repoConectarStart(d, flags);
     if (inicio.codigo !== SALIDA.esperandoAUnaPersona)
         return inicio;
-    d.mostrar(`${inicio.texto} Espero acá…`);
+    d.mostrar(`${inicio.texto} I'll wait here...`);
     let r;
     do {
         r = await repoConectarWait(d, flags);

package/dist/comandos/widget.js

@@ -1,20 +1,24 @@
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
 function textoDe(w) {
+    const anteriores = w.nextjs.archivos_anteriores;
     return [
-        "1. Instalá el paquete (con el gestor de la app, la versión exacta):",
+        "1. Install the package (with the app's package manager, the exact version):",
         `   ${w.instalar}`,
         "",
-        `2. Creá el archivo ${w.nextjs.archivo_sugerido} con este contenido (Next.js, ${w.nextjs.estado}):`,
+        `2. Create the file ${w.nextjs.archivo_sugerido} with this content (Next.js, ${w.nextjs.estado}):`,
         w.nextjs.contenido.trimEnd(),
+        ...(anteriores.length > 0
+            ? [`   If the chat is already installed in ${anteriores.join(" or ")}, update that file in place instead of creating a second one.`]
+            : []),
         "",
-        "3. Usalo en el layout que cubre las pantallas donde se traban los usuarios:",
+        "3. Use it in the layout that covers the screens where users get stuck:",
         `   ${w.nextjs.uso}`,
         "",
-        "4. Política de contenido (CSP): si la app tiene `connect-src`, agregale este origen conservando lo que ya tiene:",
+        "4. Content Security Policy (CSP): if the app has `connect-src`, add this origin and keep what it already has:",
         `   ${w.csp}`,
         "",
-        "Alternativa con <script> (disponible, no probada en una app real):",
+        "Alternative with <script> (available, not tested in a real app):",
         `   ${w.script.linea}`,
     ].join("\n");
 }

package/dist/diagnostico.js

@@ -0,0 +1,48 @@
+export const TOTAL_DE_INSTALACION = 6;
+// El orden y los nombres con que se dicen: los ids de los puntos del motor son datos suyos y no cambian.
+const DE_LA_INSTALACION = [
+    { punto: "sign-in", como: "sign-in" },
+    { punto: "repo", como: "repo" },
+    { punto: "instalacion", como: "GitHub App" },
+    { punto: "sitios", como: "allowed sites" },
+    { punto: "chat", como: "chat" },
+    { punto: "guia", como: "guide" },
+];
+const DEL_MOTOR = new Set(["instalacion", "sitios", "chat", "guia"]);
+export const lineaDeLoRevisado = (n) => `Checked ${DE_LA_INSTALACION.map((x) => x.como).slice(0, -1).join(", ")} and ${DE_LA_INSTALACION.at(-1).como}: ${n} of ${TOTAL_DE_INSTALACION}, at no cost.`;
+export const nombreDelPunto = (punto) => DE_LA_INSTALACION.find((x) => x.punto === punto)?.como ?? punto;
+export function puntoDeSesion() {
+    return { punto: "sign-in", ok: true, mensaje: "This request was authenticated: you're signed in.", grupo: "instalacion" };
+}
+export function puntoDelRepo(local, repoDelProyecto) {
+    const mal = (mensaje) => ({ punto: "repo", ok: false, mensaje, grupo: "instalacion" });
+    if (local.repo === null) {
+        if (local.motivo === "sin_git")
+            return mal("This folder isn't a git repo, so I can't tell which repo it is.");
+        if (local.motivo === "sin_origin")
+            return mal("This repo has no «origin» remote, so I can't tell which repo it is.");
+        return mal("The «origin» of this repo isn't a GitHub repo.");
+    }
+    if (local.repo.toLowerCase() !== repoDelProyecto.toLowerCase()) {
+        return mal(`The origin of this folder is ${local.repo}, not the project's repo ${repoDelProyecto}.`);
+    }
+    return { punto: "repo", ok: true, mensaje: `The origin of this folder is ${local.repo}, the project's repo.`, grupo: "instalacion" };
+}
+/** Reparte los puntos del motor en los dos grupos y suma los dos locales al de la instalación. */
+export function agruparPuntos(g, locales) {
+    const delMotor = g.puntos.map((p) => ({ ...p, grupo: p.grupo ?? (DEL_MOTOR.has(p.punto) ? "instalacion" : "prueba") }));
+    const instalacion = [...locales, ...delMotor.filter((p) => p.grupo === "instalacion")];
+    // Un punto del grupo que el motor no mandó no se da por bueno: se dice que falta y cuenta como no ok.
+    for (const { punto } of DE_LA_INSTALACION) {
+        if (!instalacion.some((p) => p.punto === punto)) {
+            instalacion.push({ punto, ok: false, mensaje: "The engine didn't report this point.", grupo: "instalacion" });
+        }
+    }
+    const orden = (p) => {
+        const i = DE_LA_INSTALACION.findIndex((x) => x.punto === p.punto);
+        return i === -1 ? DE_LA_INSTALACION.length : i;
+    };
+    return { instalacion: instalacion.sort((a, b) => orden(a) - orden(b)), prueba: delMotor.filter((p) => p.grupo === "prueba") };
+}
+/** Cuántos de los seis puntos de la instalación están bien (los extras que un motor nuevo sume no cambian el seis). */
+export const contarBuenos = (instalacion) => DE_LA_INSTALACION.filter(({ punto }) => instalacion.some((p) => p.punto === punto && p.ok)).length;

package/dist/entorno.js

@@ -3,17 +3,19 @@
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { chmodSync, closeSync, constants, fchmodSync, fstatSync, linkSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, realpathSync, renameSync, rmSync, writeSync, } from "node:fs";
+import { NO_LEIDO } from "./lectura.js";
 import { homedir, hostname } from "node:os";
 import { basename, dirname, join } from "node:path";
-import { buscarProyecto, canjear, configurar, leerWidget, crearConexion, crearProyecto, elegirOrigen, esClaveDeConsultaDelProyecto, leerCatalogo, leerConfiguracion, leerGuia, leerProyecto, listarClaves, pedirCodigo, quienSoy, revocarPropia, subirLogo, ultimaConexion, urlDeLaApi, publicarGuia, revisarGuia, } from "./api.js";
+import { buscarProyecto, canjear, configurar, leerDiagnostico, leerPrueba, leerWidget, pedirPrueba, crearConexion, crearProyecto, elegirOrigen, esClaveDeConsultaDelProyecto, leerCatalogo, leerConfiguracion, leerGuia, leerProyecto, listarClaves, pedirCodigo, quienSoy, revocarPropia, subirLogo, ultimaConexion, urlDeLaApi, publicarGuia, revisarGuia, leerVersionesDeLaGuia, } from "./api.js";
 import { crearCandados } from "./candado.js";
-import { esCarpetaReal, rutaRealOEnNada } from "./comandos/instalacion.js";
+import { esCarpetaReal, esEnlaceReal, rutaRealOEnNada } from "./comandos/instalacion.js";
 import { DESCRIPCION } from "./comandos/describir.js";
 import { almacenDeArchivo } from "./guardado/archivo.js";
 import { crearGuardado } from "./guardado/index.js";
 import { almacenDeLlavero } from "./guardado/llavero.js";
 import { crearGuardaDeSecretos } from "./secreto-a-archivo.js";
 import { crearRegistroDeIdempotencia } from "./idempotencia.js";
+import { crearRegistroDePruebas } from "./pruebas-guardadas.js";
 import { TRAMO_MAXIMO_MS } from "./sondeo.js";
 // El `.tmp` se crea en exclusiva (`wx`: falla si quedó algo, enlace incluido, en vez de escribir a
 // través de él) y el `fchmod` va aparte porque el modo de `open` pasa por la umask del proceso.
@@ -50,7 +52,7 @@ export const fsReal = {
             return realpathSync(p);
         }
         catch {
-            throw new Error(`No puedo resolver la ruta real de ${p} (¿un enlace roto?); no guardo nada ahí.`);
+            throw new Error(`I can't resolve the real path of ${p} (a broken symlink?); I'm not saving anything there.`);
         }
     },
     // `lstat` y no `existsSync`: éste sigue el enlace y ante uno roto dice «no existe», y el control
@@ -251,7 +253,7 @@ export const TOPE_DEL_ARCHIVO_DEL_REPO = 64 * 1024;
 // Lo que devuelve `leer` cuando hay ALGO ahí que no se lee (un enlace, una carpeta, algo enorme, sin
 // permiso). No es JSON a propósito: `proyecto crear` lo trata como un archivo distinto (sale 4, «no lo
 // toqué») sin que nada de lo que hay ahí llegue a la salida.
-export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(no se lee)";
+export const ARCHIVO_QUE_NO_SE_LEE = "\u0000(unreadable)";
 // Un archivo que la persona nombra (el logo) con las mismas defensas que los del repo: sin seguir
 // enlaces, sin FIFOs que cuelguen, sólo archivos comunes y con tope (se lee tope + 1 por si crece).
 export function leerArchivoChico(p, tope) {
@@ -261,11 +263,11 @@ export function leerArchivoChico(p, tope) {
     }
     catch (e) {
         const code = e.code;
-        return { error: code === "ENOENT" ? "no existe" : code === "ELOOP" ? "es un enlace" : "no se pudo abrir" };
+        return { error: code === "ENOENT" ? NO_LEIDO.noExiste : code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir };
     }
     try {
         if (!fstatSync(fd).isFile())
-            return { error: "no es un archivo común" };
+            return { error: NO_LEIDO.noEsComun };
         const buf = Buffer.alloc(tope + 1);
         let n = 0;
         for (;;) {
@@ -274,12 +276,12 @@ export function leerArchivoChico(p, tope) {
                 break;
             n += leidos;
             if (n > tope)
-                return { error: "es demasiado grande" };
+                return { error: NO_LEIDO.demasiadoGrande };
         }
         return { bytes: new Uint8Array(buf.subarray(0, n)) };
     }
     catch {
-        return { error: "no se pudo leer" };
+        return { error: NO_LEIDO.noSePudoLeer };
     }
     finally {
         closeSync(fd);
@@ -298,7 +300,7 @@ export function archivosDelRepo(avisar) {
         }
     };
     const noSeLee = (p, porque) => {
-        avisar(`No leo ${p}: ${porque}.`);
+        avisar(`I can't read ${p}: ${porque}.`);
         return ARCHIVO_QUE_NO_SE_LEE;
     };
     return {
@@ -307,7 +309,7 @@ export function archivosDelRepo(avisar) {
             if (carpeta === "ausente")
                 return null;
             if (carpeta === "ajena")
-                return noSeLee(p, `${basename(dirname(p))} no es una carpeta común (¿un enlace?)`);
+                return noSeLee(p, `${basename(dirname(p))} isn't a regular folder (a symlink?)`);
             let fd;
             try {
                 // O_NOFOLLOW: un enlace en el último tramo falla (ELOOP) en vez de abrir su destino.
@@ -318,14 +320,14 @@ export function archivosDelRepo(avisar) {
                 const code = e.code;
                 if (code === "ENOENT")
                     return null;
-                return noSeLee(p, code === "ELOOP" ? "es un enlace" : "no se pudo abrir");
+                return noSeLee(p, code === "ELOOP" ? NO_LEIDO.esUnEnlace : NO_LEIDO.noSePudoAbrir);
             }
             try {
                 const st = fstatSync(fd);
                 if (!st.isFile())
-                    return noSeLee(p, "no es un archivo común");
+                    return noSeLee(p, NO_LEIDO.noEsComun);
                 if (st.size > TOPE_DEL_ARCHIVO_DEL_REPO)
-                    return noSeLee(p, "es demasiado grande");
+                    return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 // Se lee hasta el tope + 1 y no `st.size`: el archivo puede crecer entre el fstat y la lectura.
                 const buf = Buffer.alloc(TOPE_DEL_ARCHIVO_DEL_REPO + 1);
                 let n = 0;
@@ -335,12 +337,12 @@ export function archivosDelRepo(avisar) {
                         break;
                     n += leidos;
                     if (n > TOPE_DEL_ARCHIVO_DEL_REPO)
-                        return noSeLee(p, "es demasiado grande");
+                        return noSeLee(p, NO_LEIDO.demasiadoGrande);
                 }
                 return buf.subarray(0, n).toString("utf8");
             }
             catch {
-                return noSeLee(p, "no se pudo leer");
+                return noSeLee(p, NO_LEIDO.noSePudoLeer);
             }
             finally {
                 closeSync(fd);
@@ -354,7 +356,7 @@ export function archivosDelRepo(avisar) {
             const dir = dirname(p);
             mkdirSync(dir, { recursive: true });
             if (carpetaPropia(dir) !== "propia")
-                throw new Error(`${dir} no es una carpeta común`);
+                throw new Error(`${dir} isn't a regular folder`);
             const tmp = join(dir, `.${basename(p)}.${randomUUID()}.tmp`);
             try {
                 const fd = openSync(tmp, "wx", 0o644);
@@ -403,6 +405,11 @@ export function entornoReal(env = process.env) {
         ahora: Date.now,
         avisar,
     });
+    // El pedido de `probar` (intento + última prueba), con el mismo almacén y la misma regla: fuera de un repo.
+    const rutaDePruebas = join(dirname(rutaDelArchivo), "pruebas.json");
+    const pruebas = crearRegistroDePruebas({
+        origen: api.origin, almacen: almacenDeArchivo(rutaDePruebas, fsReal), rutaDelArchivo: rutaDePruebas, fs: fsReal, ahora: Date.now, avisar,
+    });
     const dormir = (ms) => new Promise((r) => setTimeout(r, ms));
     const cwd = process.cwd();
     // Los candados de `claves crear` viven al lado de las credenciales, nunca en un repo.
@@ -460,7 +467,7 @@ export function entornoReal(env = process.env) {
         guia: {
             ...configurarEnElMotor,
             leerArchivoChico, fetch, gitDeclarado: gitRapido,
-            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen,
+            revisar: revisarGuia, publicar: publicarGuia, ver: leerGuia, elegir: elegirOrigen, versiones: leerVersionesDeLaGuia,
         },
         claves: {
             ...configurarEnElMotor,
@@ -477,9 +484,16 @@ export function entornoReal(env = process.env) {
         // para lo que la terminal dice de sí misma.
         instalacion: {
             ...configurarEnElMotor,
-            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal,
+            leerArchivoChico, rutaReal: rutaRealOEnNada, esCarpeta: esCarpetaReal, esEnlace: esEnlaceReal,
             escribir: archivosDelRepo(avisar).escribir,
             terminal: DESCRIPCION.version,
         },
+        prueba: {
+            api, guardado, git: gitReal, cwd, avisar, pruebas, generar: randomUUID, ahora: Date.now, dormir, tramoMs,
+            buscarProyecto: configurarEnElMotor.buscarProyecto,
+            leerDiagnostico: (a, clave, id) => leerDiagnostico(a, clave, id, fetch),
+            pedirPrueba: (a, clave, id, intento) => pedirPrueba(a, clave, id, intento, fetch),
+            leerPrueba: (a, clave, id, pruebaId, plazoMs) => leerPrueba(a, clave, id, pruebaId, fetch, plazoMs),
+        },
     };
 }

package/dist/flags-por-comando.js

@@ -1,28 +1,34 @@
 // Qué comandos aceptan cada flag que no es global. Un flag que no aplica sale 3 en vez de ignorarse:
-// un asistente que pasa `--repo` a `quien-soy` creería que preguntó por ese repo. Vive aparte de
-// `cli.ts` (que corre al importarse) para poder probarse sin lanzar el binario.
+// un asistente que pasa `--repo` a `whoami` creería que preguntó por ese repo. Vive aparte de
+// `cli.ts` (que corre al importarse) para poder probarse sin lanzar el binario. Los nombres de los
+// campos son los de `Flags`; los textos nombran los flags y comandos canónicos.
 const DE_CONFIGURAR_CON_REPO = [
-    "configuracion", "chat prender", "chat apagar", "chat marca", "chat logo", "sitios agregar", "sitios quitar",
-    "datos fijar", "politica fijar", "claves crear", "claves listar", "claves revocar",
-    "guia revisar", "guia publicar", "guia ver", "guia usar",
+    "config", "chat on", "chat off", "chat brand", "chat logo", "sites add", "sites remove",
+    "data set", "policy set", "keys create", "keys list", "keys revoke",
+    "guide check", "guide publish", "guide show", "guide use", "guide versions",
 ];
 export const FLAGS_POR_COMANDO = [
-    { flags: ["start", "wait"], comandos: ["login", "repo conectar"], texto: "--start y --wait son de `supcoflow login` y `supcoflow repo conectar`." },
+    { flags: ["start"], comandos: ["login", "repo connect"], texto: "--start belongs to `supcoflow login` and `supcoflow repo connect`." },
+    { flags: ["wait"], comandos: ["login", "repo connect", "test"], texto: "--wait belongs to `supcoflow login`, `supcoflow repo connect` and `supcoflow test`." },
     {
-        flags: ["repo"], comandos: ["repo conectar", "proyecto crear", "proyecto ver", ...DE_CONFIGURAR_CON_REPO, "widget", "instalacion anotar"],
-        texto: "--repo es de `supcoflow repo conectar`, `proyecto crear|ver`, `widget`, `instalacion anotar` y los comandos que configuran un proyecto (no de `catalogo`).",
+        flags: ["repo"], comandos: ["repo connect", "project create", "project show", ...DE_CONFIGURAR_CON_REPO, "widget", "install record", "diagnose", "test"],
+        texto: "--repo belongs to `supcoflow repo connect`, `project create|show`, `widget`, `install record`, `diagnose`, `test` and the commands that configure a project (not to `catalog`).",
     },
-    { flags: ["install", "test"], comandos: ["proyecto crear"], texto: "--install y --test son de `supcoflow proyecto crear`." },
-    { flags: ["sitio"], comandos: ["sitios agregar", "sitios quitar"], texto: "--sitio es de `supcoflow sitios agregar|quitar`." },
-    { flags: ["titulo", "saludo", "tema"], comandos: ["chat marca"], texto: "--titulo, --saludo y --tema son de `supcoflow chat marca`." },
-    { flags: ["archivo"], comandos: ["chat logo"], texto: "--archivo es de `supcoflow chat logo`." },
-    { flags: ["permitir"], comandos: ["datos fijar"], texto: "--permitir es de `supcoflow datos fijar`." },
-    { flags: ["modo"], comandos: ["politica fijar"], texto: "--modo es de `supcoflow politica fijar`." },
-    { flags: ["nombre", "guardarEn"], comandos: ["claves crear"], texto: "--nombre y --guardar-en son de `supcoflow claves crear`." },
-    { flags: ["origen"], comandos: ["guia usar"], texto: "--origen es de `supcoflow guia usar`." },
-    { flags: ["desdeGithub"], comandos: ["guia publicar"], texto: "--desde-github es de `supcoflow guia publicar`." },
-    { flags: ["id"], comandos: ["claves revocar"], texto: "--id es de `supcoflow claves revocar`." },
-    { flags: ["skill", "app"], comandos: ["instalacion anotar"], texto: "--skill y --app son de `supcoflow instalacion anotar`." },
+    { flags: ["install", "test"], comandos: ["project create"], texto: "--install and --test belong to `supcoflow project create`." },
+    { flags: ["site"], comandos: ["sites add", "sites remove"], texto: "--site belongs to `supcoflow sites add|remove`." },
+    { flags: ["title", "greeting", "theme"], comandos: ["chat brand"], texto: "--title, --greeting and --theme belong to `supcoflow chat brand`." },
+    { flags: ["file"], comandos: ["chat logo", "install record"], texto: "--file belongs to `supcoflow chat logo` and `supcoflow install record`." },
+    { flags: ["allow"], comandos: ["data set"], texto: "--allow belongs to `supcoflow data set`." },
+    { flags: ["mode"], comandos: ["policy set"], texto: "--mode belongs to `supcoflow policy set`." },
+    { flags: ["name", "saveTo"], comandos: ["keys create"], texto: "--name and --save-to belong to `supcoflow keys create`." },
+    { flags: ["source"], comandos: ["guide use"], texto: "--source belongs to `supcoflow guide use`." },
+    { flags: ["fromGithub"], comandos: ["guide publish"], texto: "--from-github belongs to `supcoflow guide publish`." },
+    { flags: ["id"], comandos: ["keys revoke"], texto: "--id belongs to `supcoflow keys revoke`." },
+    {
+        flags: ["authorizeSpend", "ceiling", "expectPolicy", "message", "testId"], comandos: ["test"],
+        texto: "--authorize-spend, --ceiling, --expect-policy, --message and --test-id belong to `supcoflow test`.",
+    },
+    { flags: ["skill", "app"], comandos: ["install record"], texto: "--skill and --app belong to `supcoflow install record`." },
 ];
 /** El mensaje del primer flag presente que el comando no acepta, o null si todo aplica. */
 export function flagQueNoAplica(comando, presentes) {

package/dist/guardado/archivo.js

@@ -21,7 +21,7 @@ export function almacenDeArchivo(ruta, fs) {
             v = undefined;
         }
         if (typeof v !== "object" || v === null || Array.isArray(v)) {
-            throw new Error(`No entiendo el archivo de credenciales ${ruta}; borralo y volvé a iniciar sesión.`);
+            throw new Error(`I don't understand the credentials file ${ruta}; delete it and log in again.`);
         }
         return v;
     }
@@ -44,7 +44,7 @@ export function almacenDeArchivo(ruta, fs) {
                 return null;
             const r = t[cuenta];
             if (!esRegistro(r))
-                throw new Error(`No entiendo el archivo de credenciales ${ruta}; borralo y volvé a iniciar sesión.`);
+                throw new Error(`I don't understand the credentials file ${ruta}; delete it and log in again.`);
             return { valor: r.valor, escritoEn: r.escritoEn };
         },
         async escribir(cuenta, r) {