supcoflow 0.6.0 → 0.8.0

package/dist/api.js

@@ -9,7 +9,7 @@ export function urlDeLaApi(env) {
     const crudo = env.SUPCOFLOW_API_URL;
     if (crudo === undefined || crudo === "")
         return new URL(API_DE_PRODUCCION);
-    const invalida = () => new FalloDeLaTerminal(SALIDA.entradaInvalida, "api_url_invalida", "SUPCOFLOW_API_URL tiene que ser https, o http contra localhost.");
+    const invalida = () => new FalloDeLaTerminal(SALIDA.entradaInvalida, "api_url_invalida", "SUPCOFLOW_API_URL must be https, or http against localhost.");
     let u;
     try {
         u = new URL(crudo);
@@ -21,9 +21,9 @@ export function urlDeLaApi(env) {
         return new URL(u.origin);
     throw invalida();
 }
-// A mano a propósito: tiene que coincidir con package.json (0.6.0); sólo identifica a la terminal
-// en los logs del motor, no decide nada.
-const VERSION = "0.6.0";
+// A mano a propósito: tiene que coincidir con package.json (lo pinza test/describir.test.ts); sólo
+// identifica a la terminal en los logs del motor, no decide nada.
+const VERSION = "0.8.0";
 const PLAZO_POR_DEFECTO_MS = 15_000;
 // Los dos POST que crean algo: detrás, el motor acuña con Vercel Connect y le pregunta a GitHub varias
 // veces (instalación, repos, comandos, rama). Con 15 s una respuesta lenta pero buena se cortaba y
@@ -49,7 +49,7 @@ async function pedir(api, ruta, init, f, plazoMs) {
         texto = await res.text();
     }
     catch {
-        throw new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", "No pude comunicarme con el motor (red caída o demora).");
+        throw new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", "I couldn't reach the engine (the network is down or it took too long).");
     }
     let cuerpo;
     try {
@@ -59,15 +59,15 @@ async function pedir(api, ruta, init, f, plazoMs) {
         cuerpo = undefined;
     }
     if (typeof cuerpo !== "object" || cuerpo === null || Array.isArray(cuerpo)) {
-        throw new FalloDeLaTerminal(SALIDA.inesperado, "respuesta_inesperada", `El motor respondió ${res.status} sin JSON.`);
+        throw new FalloDeLaTerminal(SALIDA.inesperado, "respuesta_inesperada", `The engine answered ${res.status} without JSON.`);
     }
     return { status: res.status, cuerpo: cuerpo };
 }
 function sinServicio(status) {
-    return new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", `El motor respondió ${status}; probá en unos minutos.`);
+    return new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", `The engine answered ${status}; try again in a few minutes.`);
 }
 function inesperada(status) {
-    return new FalloDeLaTerminal(SALIDA.inesperado, "respuesta_inesperada", `El motor respondió ${status} con algo que no esperaba.`);
+    return new FalloDeLaTerminal(SALIDA.inesperado, "respuesta_inesperada", `The engine answered ${status} with something I didn't expect.`);
 }
 const texto = (v) => (typeof v === "string" ? v : null);
 const CLIENT_ID = "supcoflow-cli";
@@ -76,7 +76,7 @@ const FORMULARIO = { "content-type": "application/x-www-form-urlencoded" };
 export async function pedirCodigo(api, maquina, f) {
     const { status, cuerpo: c } = await pedir(api, "/api/dispositivo/codigo", { method: "POST", headers: FORMULARIO, body: new URLSearchParams({ client_id: CLIENT_ID, maquina }).toString() }, f);
     if (status === 429 || status === 503) {
-        throw new FalloDeLaTerminal(SALIDA.inesperado, texto(c.error) ?? "demasiados_pedidos", "El motor no acepta más pedidos ahora; probá en unos minutos.");
+        throw new FalloDeLaTerminal(SALIDA.inesperado, texto(c.error) ?? "demasiados_pedidos", "The engine isn't accepting more requests right now; try again in a few minutes.");
     }
     if (status >= 500)
         throw sinServicio(status);
@@ -112,7 +112,7 @@ const bearer = (clave) => ({ authorization: `Bearer ${clave}` });
 export async function quienSoy(api, clave, f) {
     const { status, cuerpo: c } = await pedir(api, "/api/yo", { method: "GET", headers: bearer(clave) }, f);
     if (status === 401) {
-        throw new FalloDeLaTerminal(SALIDA.faltaLogin, "clave_invalida", texto(c.message) ?? "La clave ya no vale: iniciá sesión de nuevo.");
+        throw new FalloDeLaTerminal(SALIDA.faltaLogin, "clave_invalida", texto(c.message) ?? "The key is no longer valid: log in again.");
     }
     if (status >= 500)
         throw sinServicio(status);
@@ -146,16 +146,16 @@ async function conClave(api, clave, ruta, init, f, plazoMs) {
     const error = texto(r.cuerpo.error) ?? "respuesta_inesperada";
     const message = (porDefecto) => taparSecretos(texto(r.cuerpo.message) ?? porDefecto);
     if (r.status === 401) {
-        throw new FalloDeLaTerminal(SALIDA.faltaLogin, "clave_invalida", message("La clave ya no vale: iniciá sesión de nuevo."));
+        throw new FalloDeLaTerminal(SALIDA.faltaLogin, "clave_invalida", message("The key is no longer valid: log in again."));
     }
     if (r.status === 403 && (error === "requiere_persona" || error === "clave_de_consulta")) {
-        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, error, message("Esto lo tiene que hacer una persona con sesión."));
+        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, error, message("A person who is logged in has to do this."));
     }
     if (r.status === 422 && error === "cuenta_sin_github") {
-        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, error, message("Tu cuenta no tiene GitHub asociado."));
+        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, error, message("Your account has no GitHub linked."));
     }
     if (r.status === 400 && error === "repo_invalido") {
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message("El repo tiene que ser owner/repo."));
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message("The repo must be owner/repo."));
     }
     if (r.status >= 500)
         throw sinServicio(r.status);
@@ -181,7 +181,7 @@ function aProyecto(v, status) {
 function rechazada(r) {
     const error = texto(r.cuerpo.error);
     if (r.status >= 400 && r.status < 500 && error) {
-        return new FalloDeLaTerminal(SALIDA.entradaInvalida, error, taparSecretos(texto(r.cuerpo.message) ?? `El motor rechazó el pedido (${r.status}).`));
+        return new FalloDeLaTerminal(SALIDA.entradaInvalida, error, taparSecretos(texto(r.cuerpo.message) ?? `The engine rejected the request (${r.status}).`));
     }
     return inesperada(r.status);
 }
@@ -309,6 +309,10 @@ export function publicarGuia(api, clave, proyectoId, cuerpo, f) {
 export function leerGuia(api, clave, proyectoId, f) {
     return conClave(api, clave, `${rutaDeLaGuia(proyectoId)}?comprobar=1`, { method: "GET" }, f, PLAZO_DE_ALTA_MS);
 }
+// Las publicaciones del repo y la guía que rige ahora (`guide versions`): sólo lectura, la misma clase que `leerGuia`.
+export function leerVersionesDeLaGuia(api, clave, proyectoId, f) {
+    return conClave(api, clave, `${rutaDeLaGuia(proyectoId)}/versiones`, { method: "GET" }, f, PLAZO_DE_ALTA_MS);
+}
 export function elegirOrigen(api, clave, proyectoId, origen, f) {
     return conClave(api, clave, `${rutaDeLaGuia(proyectoId)}/origen`, { method: "POST", headers: JSON_BODY, body: JSON.stringify({ origen }) }, f);
 }
@@ -320,20 +324,121 @@ function aWidget(v, status) {
     const [tenantId, projectId, backendUrl, version, instalar, csp] = [v.tenant_id, v.project_id, v.backend_url, v.version, v.instalar, v.csp].map(texto);
     const [archivo, contenido, uso] = [n.archivo_sugerido, n.contenido, n.uso].map(texto);
     const linea = texto(s.linea);
+    // AD9: `archivos_anteriores` vive sólo dentro de `nextjs`, al lado de `archivo_sugerido`; arriba de todo no se lee.
+    const anteriores = listaDeTextos(n.archivos_anteriores);
+    if (anteriores === null)
+        throw inesperada(status);
     if (!tenantId || !projectId || !backendUrl || !version || !instalar || !csp || v.paquete !== "@supcoflow/chat"
         || (n.estado !== "probando" && n.estado !== "soportado") || !archivo || !contenido || !uso
         || s.estado !== "disponible_sin_soporte" || !linea)
         throw inesperada(status);
     return {
         tenant_id: tenantId, project_id: projectId, backend_url: backendUrl, paquete: "@supcoflow/chat", version, instalar,
-        nextjs: { estado: n.estado, archivo_sugerido: archivo, contenido, uso },
+        nextjs: { estado: n.estado, archivo_sugerido: archivo, archivos_anteriores: anteriores, contenido, uso },
         script: { estado: "disponible_sin_soporte", linea },
         csp,
     };
 }
+// Una lista de textos no vacíos; ausente es lista vacía (un motor sin el campo), y cualquier otra forma es null.
+function listaDeTextos(v) {
+    if (v === undefined || v === null)
+        return [];
+    if (!Array.isArray(v))
+        return null;
+    const textos = v.map(texto);
+    return textos.every((t) => t !== null && t !== "") ? textos : null;
+}
 export async function leerWidget(api, clave, proyectoId, f) {
     const r = await conClave(api, clave, `/api/proyectos/${encodeURIComponent(proyectoId)}/widget`, { method: "GET" }, f);
     if (r.status !== 200)
         throw rechazada(r);
     return aWidget(r.cuerpo, r.status);
 }
+// ---- La prueba (bloque 7) ----
+const rutaDelProyecto = (proyectoId) => `/api/proyectos/${encodeURIComponent(proyectoId)}`;
+const numeroONull = (v) => (v === null ? null : typeof v === "number" && Number.isFinite(v) ? v : undefined);
+export async function leerDiagnostico(api, clave, proyectoId, f) {
+    const r = await conClave(api, clave, `${rutaDelProyecto(proyectoId)}/diagnostico`, { method: "GET" }, f);
+    if (r.status !== 200)
+        throw rechazada(r);
+    const c = r.cuerpo;
+    const puntos = Array.isArray(c.puntos) ? c.puntos.map((x) => objeto(x, r.status)) : null;
+    const [saldo, tope, comprometido] = [c.saldo_usd, c.tope_usd, c.comprometido_usd].map(numeroONull);
+    if (typeof c.listo !== "boolean" || puntos === null || !texto(c.politica) || typeof c.techo_usd !== "number"
+        || saldo === undefined || tope === undefined || comprometido === undefined
+        || (c.prueba_abierta !== null && !texto(c.prueba_abierta))
+        || puntos.some((p) => !texto(p.punto) || typeof p.ok !== "boolean" || typeof p.mensaje !== "string"))
+        throw inesperada(r.status);
+    return {
+        listo: c.listo,
+        puntos: puntos.map((p) => ({
+            punto: p.punto, ok: p.ok, mensaje: taparSecretos(p.mensaje),
+            ...(p.grupo === "instalacion" || p.grupo === "prueba" ? { grupo: p.grupo } : {}),
+        })),
+        politica: c.politica,
+        techoUsd: c.techo_usd,
+        saldoUsd: saldo, topeUsd: tope, comprometidoUsd: comprometido,
+        pruebaAbierta: texto(c.prueba_abierta),
+    };
+}
+// Sin `conClave`: su 401/403/5xx lanzan, y acá cada uno tiene que decidir qué pasa con el intento.
+// `idempotency_en_curso` es ambigua: otro intento con la misma clave sigue corriendo y puede crearla.
+// Un 503 de la pausa de despachos (D10) también: el motor no guardó nada, pero conservar el intento no
+// cuesta (el reintento con la misma clave crea la prueba una sola vez) y un 503 genérico no se distingue.
+export async function pedirPrueba(api, clave, proyectoId, intento, f) {
+    const cuerpo = { techo_usd: intento.techoUsd };
+    if (intento.mensaje !== null)
+        cuerpo.mensaje = intento.mensaje;
+    if (intento.politicaEsperada !== null)
+        cuerpo.politica_esperada = intento.politicaEsperada;
+    let r;
+    try {
+        r = await pedir(api, `${rutaDelProyecto(proyectoId)}/pruebas`, {
+            method: "POST", headers: { ...JSON_BODY, ...bearer(clave), "idempotency-key": intento.clave }, body: JSON.stringify(cuerpo),
+        }, f, PLAZO_DE_ALTA_MS);
+    }
+    catch (e) {
+        const fallo = e instanceof FalloDeLaTerminal ? e : new FalloDeLaTerminal(SALIDA.inesperado, "motor_inalcanzable", "I couldn't reach the engine.");
+        return { tipo: "ambigua", error: fallo.error, message: fallo.message };
+    }
+    const error = texto(r.cuerpo.error);
+    const message = taparSecretos(texto(r.cuerpo.message) ?? `The engine answered ${r.status}.`);
+    if (r.status === 202 || r.status === 200 || r.status === 201) {
+        const [pruebaId, reporteId, estado] = [r.cuerpo.prueba_id, r.cuerpo.reporte_id, r.cuerpo.estado].map(texto);
+        if (pruebaId && /^prb_[0-9a-f]{16}$/.test(pruebaId) && reporteId && estado)
+            return { tipo: "aceptada", pruebaId, reporteId, estado };
+        return { tipo: "ambigua", error: "respuesta_inesperada", message: `The engine answered ${r.status} without the test.` };
+    }
+    if (r.status >= 500 || (r.status === 409 && error === "idempotency_en_curso")) {
+        return { tipo: "ambigua", error: error ?? "motor_inalcanzable", message };
+    }
+    if (r.status >= 400)
+        return { tipo: "rechazo", status: r.status, error: error ?? "rechazado", message, cuerpo: r.cuerpo };
+    return { tipo: "ambigua", error: "respuesta_inesperada", message: `The engine answered ${r.status} with something I didn't expect.` };
+}
+export async function leerPrueba(api, clave, proyectoId, pruebaId, f, plazoMs) {
+    const r = await conClave(api, clave, `${rutaDelProyecto(proyectoId)}/pruebas/${encodeURIComponent(pruebaId)}`, { method: "GET" }, f, plazoMs);
+    if (r.status !== 200)
+        throw rechazada(r);
+    const c = r.cuerpo;
+    const cobro = objeto(c.cobro, r.status);
+    const usd = numeroONull(cobro.usd);
+    if (!texto(c.prueba_id) || !texto(c.estado) || typeof cobro.techo_usd !== "number" || usd === undefined
+        || (cobro.estado !== null && !texto(cobro.estado)))
+        throw inesperada(r.status);
+    const rep = c.reporte === null || c.reporte === undefined ? null : objeto(c.reporte, r.status);
+    const run = c.run === null || c.run === undefined ? null : objeto(c.run, r.status);
+    const issue = c.issue === null || c.issue === undefined ? null : objeto(c.issue, r.status);
+    if (issue !== null && (typeof issue.numero !== "number" || !texto(issue.url)))
+        throw inesperada(r.status);
+    return {
+        pruebaId: c.prueba_id,
+        estado: c.estado,
+        abierta: typeof c.abierta === "boolean" ? c.abierta : null,
+        mensaje: texto(c.mensaje) === null ? null : taparSecretos(c.mensaje),
+        reporte: rep === null || !texto(rep.id) || !texto(rep.url) ? null : { id: rep.id, url: rep.url },
+        run: run === null ? null : { id: String(run.id), status: String(run.status), motivo: texto(run.motivo) },
+        issue: issue === null ? null : { numero: issue.numero, url: issue.url },
+        cobro: { estado: texto(cobro.estado), usd, techo_usd: cobro.techo_usd },
+    };
+}

package/dist/argumentos.js

@@ -1,108 +1,122 @@
 import { parseArgs } from "node:util";
+import { COMANDOS_VIEJOS, FLAGS_VIEJOS } from "./alias.js";
 import { FalloDeLaTerminal, SALIDA } from "./contrato.js";
 export const COMANDOS_COMPUESTOS = [
-    "repo conectar", "proyecto crear", "proyecto ver",
-    "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",
-    "instalacion anotar",
+    "repo connect", "project create", "project show",
+    "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",
+    "install record",
 ];
-// Sólo estas primeras palabras admiten una segunda: cualquier otro par sigue siendo «de más».
-const PRIMERAS_PALABRAS = new Set(COMANDOS_COMPUESTOS.map((c) => c.split(" ")[0]));
+// Sólo estas primeras palabras admiten una segunda: cualquier otro par sigue siendo «de más». Entran también las de
+// los nombres viejos (`guia publicar`), que se resuelven más abajo.
+const PRIMERAS_PALABRAS = new Set([...COMANDOS_COMPUESTOS, ...Object.keys(COMANDOS_VIEJOS)].filter((c) => c.includes(" ")).map((c) => c.split(" ")[0]));
 const FLAGS_CON_VALOR = [
-    "repo", "install", "test", "sitio", "titulo", "saludo", "archivo", "permitir", "modo", "nombre", "guardar-en", "id", "origen", "skill", "app",
+    "repo", "install", "test", "site", "title", "greeting", "file", "allow", "mode", "name", "save-to", "id", "source", "skill", "app",
+    "message", "test-id", "ceiling", "expect-policy",
 ];
+const FLAGS_BOOLEANOS = ["json", "dry-run", "help", "start", "wait", "from-github", "authorize-spend"];
+// El flag que el token nombró, ya llevado a su nombre canónico (el viejo y el nuevo cuentan como el mismo).
+const canonico = (nombre) => FLAGS_VIEJOS[nombre] ?? nombre;
+const invalida = (error, message) => new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message);
+function opciones() {
+    const o = {};
+    for (const f of FLAGS_BOOLEANOS)
+        o[f] = f === "help" ? { type: "boolean", short: "h" } : { type: "boolean" };
+    for (const f of FLAGS_CON_VALOR)
+        o[f] = { type: "string" };
+    o.theme = { type: "string", multiple: true };
+    for (const [viejo, nuevo] of Object.entries(FLAGS_VIEJOS))
+        o[viejo] = { ...o[nuevo] };
+    return o;
+}
 // strict: un flag mal escrito (`--estart`) no se ignora en silencio: un asistente creería que
 // pidió algo que no pidió.
 export function leerArgumentos(argv) {
     let parsed;
     try {
-        parsed = parseArgs({
-            args: argv,
-            strict: true,
-            allowPositionals: true,
-            options: {
-                json: { type: "boolean" },
-                "dry-run": { type: "boolean" },
-                help: { type: "boolean", short: "h" },
-                start: { type: "boolean" },
-                wait: { type: "boolean" },
-                repo: { type: "string" },
-                install: { type: "string" },
-                test: { type: "string" },
-                sitio: { type: "string" },
-                titulo: { type: "string" },
-                saludo: { type: "string" },
-                archivo: { type: "string" },
-                permitir: { type: "string" },
-                modo: { type: "string" },
-                nombre: { type: "string" },
-                "guardar-en": { type: "string" },
-                id: { type: "string" },
-                origen: { type: "string" },
-                "desde-github": { type: "boolean" },
-                skill: { type: "string" },
-                app: { type: "string" },
-                tema: { type: "string", multiple: true },
-            },
-            tokens: true,
-        });
+        parsed = parseArgs({ args: argv, strict: true, allowPositionals: true, options: opciones(), tokens: true });
     }
     catch (e) {
         const code = e.code;
         if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION") {
             const m = /'(--?[^']+)'/.exec(e.message);
-            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "flag_desconocido", `No conozco el flag ${m ? m[1] : "que pasaste"}. Probá \`supcoflow --help\`.`);
+            throw invalida("flag_desconocido", `Unknown flag ${m ? m[1] : "you passed"}. Try \`supcoflow --help\`.`);
         }
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "argumentos_invalidos", `${e.message} Probá \`supcoflow --help\`.`);
+        throw invalida("argumentos_invalidos", `${e.message} Try \`supcoflow --help\`.`);
     }
     const pos = parsed.positionals;
-    const deMas = () => new FalloDeLaTerminal(SALIDA.entradaInvalida, "argumentos_de_mas", "Pasaste más de un comando. Probá `supcoflow --help`.");
-    if (pos.length > 2 || (pos.length === 2 && !PRIMERAS_PALABRAS.has(pos[0])))
-        throw deMas();
-    // `parseArgs` se queda con el último valor de un flag repetido: un asistente que repite `--repo`
-    // creería que se usó el primero. Se mira en los tokens y se rechaza.
+    if (pos.length > 2 || (pos.length === 2 && !PRIMERAS_PALABRAS.has(pos[0]))) {
+        throw invalida("argumentos_de_mas", "You passed more than one command. Try `supcoflow --help`.");
+    }
+    const tokens = (parsed.tokens ?? []).filter((t) => t.kind === "option");
+    const viejos = [];
+    // `parseArgs` se queda con el último valor de un flag repetido: un asistente que repite `--repo` (o que pasa el
+    // nombre viejo y el nuevo de un mismo flag) creería que se usó el primero. Se mira en los tokens y se rechaza.
     for (const nombre of FLAGS_CON_VALOR) {
-        const toks = (parsed.tokens ?? []).filter((t) => t.kind === "option" && t.name === nombre);
-        if (toks.length > 1 || toks.some((t) => t.kind === "option" && t.value === "")) {
-            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "argumentos_invalidos", `--${nombre} va una sola vez y con un valor. Probá \`supcoflow --help\`.`);
+        const toks = tokens.filter((t) => canonico(t.name) === nombre);
+        if (toks.length > 1 || toks.some((t) => t.value === "")) {
+            throw invalida("argumentos_invalidos", `--${nombre} goes once, with a value. Try \`supcoflow --help\`.`);
         }
     }
-    // `--tema` sí se repite (uno por clave), pero ninguno vacío: un `--tema ""` es un error de quien arma
-    // el comando, no «sin tema».
-    if ((parsed.values.tema ?? []).some((t) => t === "")) {
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "argumentos_invalidos", "--tema va con un valor clave=valor. Probá `supcoflow --help`.");
-    }
+    for (const t of tokens)
+        if (t.name in FLAGS_VIEJOS)
+            viejos.push(`--${t.name}`);
+    // `--theme` sí se repite (uno por clave), pero ninguno vacío: un `--theme ""` es un error de quien arma
+    // el comando, no «sin tema». Se junta desde los tokens para conservar el orden entre el nombre viejo y el nuevo.
+    const tema = tokens.filter((t) => canonico(t.name) === "theme").map((t) => t.value ?? "");
+    if (tema.some((t) => t === ""))
+        throw invalida("argumentos_invalidos", "--theme goes with a key=value. Try `supcoflow --help`.");
     // Un par desconocido (`repo borrar`) queda como la primera palabra sola: el despacho la rechaza
     // como comando desconocido, con el mismo mensaje que cualquier otra.
-    const compuesto = pos.length === 2 ? `${pos[0]} ${pos[1]}` : null;
-    const comando = compuesto !== null && COMANDOS_COMPUESTOS.includes(compuesto) ? compuesto : (pos[0] ?? null);
-    const v = parsed.values;
+    const escrito = pos.length === 2 ? `${pos[0]} ${pos[1]}` : (pos[0] ?? null);
+    let comando;
+    if (escrito !== null && escrito in COMANDOS_VIEJOS) {
+        comando = COMANDOS_VIEJOS[escrito];
+        viejos.unshift(escrito);
+    }
+    else if (pos.length === 2 && COMANDOS_COMPUESTOS.includes(escrito)) {
+        comando = escrito;
+    }
+    else {
+        comando = pos[0] ?? null;
+    }
+    const un = (nombre) => {
+        const t = tokens.find((x) => canonico(x.name) === nombre);
+        return t === undefined ? null : (t.value ?? null);
+    };
+    const hay = (nombre) => tokens.some((x) => canonico(x.name) === nombre);
     return {
         comando,
+        viejos,
         flags: {
-            json: v.json === true,
-            dryRun: v["dry-run"] === true,
-            help: v.help === true,
-            start: v.start === true,
-            wait: v.wait === true,
-            repo: v.repo ?? null,
-            install: v.install ?? null,
-            test: v.test ?? null,
-            sitio: v.sitio ?? null,
-            titulo: v.titulo ?? null,
-            saludo: v.saludo ?? null,
-            archivo: v.archivo ?? null,
-            permitir: v.permitir ?? null,
-            modo: v.modo ?? null,
-            nombre: v.nombre ?? null,
-            guardarEn: v["guardar-en"] ?? null,
-            id: v.id ?? null,
-            origen: v.origen ?? null,
-            desdeGithub: v["desde-github"] === true,
-            skill: v.skill ?? null,
-            app: v.app ?? null,
-            tema: v.tema ?? [],
+            json: hay("json"),
+            dryRun: hay("dry-run"),
+            help: hay("help"),
+            start: hay("start"),
+            wait: hay("wait"),
+            repo: un("repo"),
+            install: un("install"),
+            test: un("test"),
+            site: un("site"),
+            title: un("title"),
+            greeting: un("greeting"),
+            file: un("file"),
+            allow: un("allow"),
+            mode: un("mode"),
+            name: un("name"),
+            saveTo: un("save-to"),
+            id: un("id"),
+            source: un("source"),
+            fromGithub: hay("from-github"),
+            skill: un("skill"),
+            app: un("app"),
+            authorizeSpend: hay("authorize-spend"),
+            message: un("message"),
+            testId: un("test-id"),
+            ceiling: un("ceiling"),
+            expectPolicy: un("expect-policy"),
+            theme: tema,
         },
     };
 }

package/dist/cli.js

@@ -6,12 +6,13 @@ import { revocarPropia } from "./api.js";
 import { leerArgumentos } from "./argumentos.js";
 import { clavesCrear, clavesListar, clavesRevocar } from "./comandos/claves.js";
 import { chatLogo, chatMarca, chatPrenderApagar, comandoConfiguracion, sitios } from "./comandos/configurar.js";
-import { guiaPublicar, guiaRevisar, guiaUsar, guiaVer } from "./comandos/guia.js";
+import { guiaPublicar, guiaRevisar, guiaUsar, guiaVer, guiaVersiones } from "./comandos/guia.js";
 import { instalacionAnotar } from "./comandos/instalacion.js";
 import { comandoCatalogo, datosFijar, politicaFijar } from "./comandos/datos-y-politica.js";
 import { ayuda, comandoDescribir, DESCRIPCION } from "./comandos/describir.js";
 import { loginInteractivo, loginStart, loginWait } from "./comandos/login.js";
 import { comandoLogout } from "./comandos/logout.js";
+import { diagnosticar, probar } from "./comandos/probar.js";
 import { proyectoCrear, proyectoVer } from "./comandos/proyecto.js";
 import { comandoQuienSoy } from "./comandos/quien-soy.js";
 import { repoConectarInteractivo, repoConectarStart, repoConectarWait } from "./comandos/repo-conectar.js";
@@ -21,15 +22,16 @@ import { entornoReal } from "./entorno.js";
 import { flagQueNoAplica } from "./flags-por-comando.js";
 const COMANDOS = new Set(DESCRIPCION.comandos.map((c) => c.nombre));
 const invalida = (error, message) => new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message);
+// Los nombres que la terminal tenía antes de la 0.8.0 siguen valiendo (`src/alias.ts`), pero no salen en `describe`.
 async function correr(argv) {
     // Si los argumentos no se pueden leer no se sabe qué flags hay: se mira `--json` a mano para que
     // el error salga en el formato que pidió quien llama.
     let json = argv.includes("--json");
     try {
-        const { comando, flags } = leerArgumentos(argv);
+        const { comando, flags, viejos } = leerArgumentos(argv);
         json = flags.json;
         if (comando !== null && !COMANDOS.has(comando)) {
-            throw invalida("comando_desconocido", `No conozco el comando «${comando}». Probá \`supcoflow --help\`.`);
+            throw invalida("comando_desconocido", `Unknown command «${comando}». Try \`supcoflow --help\`.`);
         }
         if (flags.help || comando === null) {
             const texto = ayuda(comando);
@@ -37,24 +39,26 @@ async function correr(argv) {
         }
         const presentes = {
             start: flags.start, wait: flags.wait, repo: flags.repo !== null, install: flags.install !== null, test: flags.test !== null,
-            sitio: flags.sitio !== null, titulo: flags.titulo !== null, saludo: flags.saludo !== null, tema: flags.tema.length > 0,
-            archivo: flags.archivo !== null, permitir: flags.permitir !== null, modo: flags.modo !== null,
-            nombre: flags.nombre !== null, guardarEn: flags.guardarEn !== null, id: flags.id !== null, origen: flags.origen !== null, desdeGithub: flags.desdeGithub,
+            site: flags.site !== null, title: flags.title !== null, greeting: flags.greeting !== null, theme: flags.theme.length > 0,
+            file: flags.file !== null, allow: flags.allow !== null, mode: flags.mode !== null,
+            name: flags.name !== null, saveTo: flags.saveTo !== null, id: flags.id !== null, source: flags.source !== null, fromGithub: flags.fromGithub,
             skill: flags.skill !== null, app: flags.app !== null,
+            authorizeSpend: flags.authorizeSpend, message: flags.message !== null, testId: flags.testId !== null,
+            ceiling: flags.ceiling !== null, expectPolicy: flags.expectPolicy !== null,
         };
         const noAplica = flagQueNoAplica(comando, Object.keys(presentes).filter((k) => presentes[k]));
         if (noAplica !== null)
             throw invalida("flag_no_aplica", noAplica);
         if (flags.start && flags.wait) {
-            throw invalida("flags_incompatibles", "--start y --wait van por separado: primero uno y después el otro.");
+            throw invalida("flags_incompatibles", "--start and --wait go separately: first one and then the other.");
         }
-        if (comando === "describir")
+        if (comando === "describe")
             return { r: comandoDescribir(), json };
         if (comando === "login") {
             // ANTES de armar el entorno: no hay cómo simular un canje sin consumirlo, y este error no
             // puede depender de leer nada guardado ni de llamar al motor.
             if (flags.wait && flags.dryRun) {
-                throw invalida("dry_run_no_soportado", "`login --wait` no tiene --dry-run: sondear consume el código. Probá `supcoflow login --start --dry-run`.");
+                throw invalida("dry_run_no_soportado", "`login --wait` has no --dry-run: polling consumes the code. Try `supcoflow login --start --dry-run`.");
             }
         }
         const e = entornoReal();
@@ -76,9 +80,9 @@ async function correr(argv) {
                     }, flags),
                     json,
                 };
-            case "quien-soy":
+            case "whoami":
                 return { r: await comandoQuienSoy({ api: e.api, guardado: e.guardado, quienSoy: e.quienSoy, avisar: e.avisar }), json };
-            case "repo conectar":
+            case "repo connect":
                 if (flags.start)
                     return { r: await repoConectarStart(e.conexion, flags), json };
                 // `--wait` sólo lee (un GET por tramo): con --dry-run haría lo mismo, así que no se rechaza.
@@ -88,50 +92,57 @@ async function correr(argv) {
                 if (flags.dryRun)
                     return { r: await repoConectarStart(e.conexion, { repo: flags.repo, dryRun: true }), json };
                 return { r: await repoConectarInteractivo({ ...e.conexion, esTty: e.esTty, mostrar: e.mostrar }, flags), json };
-            case "proyecto crear":
+            case "project create":
                 return { r: await proyectoCrear(e.proyecto, flags), json };
-            case "proyecto ver":
+            case "project show":
                 return { r: await proyectoVer(e.proyecto, flags), json };
-            case "catalogo":
+            case "catalog":
                 return { r: await comandoCatalogo(e.configurar), json };
-            case "configuracion":
+            case "config":
                 return { r: await comandoConfiguracion(e.configurar, flags), json };
-            case "chat prender":
+            case "chat on":
                 return { r: await chatPrenderApagar(e.configurar, flags, true), json };
-            case "chat apagar":
+            case "chat off":
                 return { r: await chatPrenderApagar(e.configurar, flags, false), json };
-            case "chat marca":
+            case "chat brand":
                 return { r: await chatMarca(e.configurar, flags), json };
             case "chat logo":
                 return { r: await chatLogo(e.configurar, flags), json };
-            case "sitios agregar":
+            case "sites add":
                 return { r: await sitios(e.configurar, flags, "agregar"), json };
-            case "sitios quitar":
+            case "sites remove":
                 return { r: await sitios(e.configurar, flags, "quitar"), json };
-            case "datos fijar":
+            case "data set":
                 return { r: await datosFijar(e.configurar, flags), json };
-            case "politica fijar":
+            case "policy set":
                 return { r: await politicaFijar(e.configurar, flags), json };
-            case "claves crear":
+            case "keys create":
                 return { r: await clavesCrear(e.claves, flags), json };
-            case "claves listar":
+            case "keys list":
                 return { r: await clavesListar(e.claves, flags), json };
-            case "claves revocar":
+            case "keys revoke":
                 return { r: await clavesRevocar(e.claves, flags), json };
-            case "guia revisar":
+            case "guide check":
                 return { r: await guiaRevisar(e.guia, flags), json };
-            case "guia publicar":
+            case "guide publish":
                 return { r: await guiaPublicar(e.guia, flags), json };
-            case "guia ver":
+            case "guide show":
                 return { r: await guiaVer(e.guia, flags), json };
-            case "guia usar":
+            case "guide use":
                 return { r: await guiaUsar(e.guia, flags), json };
+            case "guide versions":
+                return { r: await guiaVersiones(e.guia, flags), json };
             case "widget":
                 return { r: await widget(e.widget, flags), json };
-            case "instalacion anotar":
+            case "install record":
                 return { r: await instalacionAnotar(e.instalacion, flags), json };
+            case "diagnose":
+                return { r: await diagnosticar(e.prueba, flags), json };
+            case "test":
+                // El alias viejo (`probar`, o `--autorizo-gasto` con cualquier nombre) no puede ampliar lo autorizado: lo marca.
+                return { r: await probar(e.prueba, { ...flags, viejo: viejos.includes("probar") || viejos.includes("--autorizo-gasto") }), json };
         }
-        throw new Error(`comando sin despacho: ${comando}`);
+        throw new Error(`command without dispatch: ${comando}`);
     }
     catch (e) {
         return { r: resultadoDeFallo(e), json };

package/dist/comandos/clave-vigente.js

@@ -7,11 +7,11 @@ export async function claveVigente(guardado, origen) {
     // «Iniciá sesión» con la clave guardada en un llavero que no contestó invita a un login que la
     // pisaría: no es «sin sesión», es «no pude mirar» (Review Focus 12).
     if (vigente === null && !lectura.completa) {
-        const message = "No pude leer la clave guardada (el llavero no respondió). Desbloquealo y probá de nuevo.";
+        const message = "I couldn't read the saved key (the keychain didn't respond). Unlock it and try again.";
         return { ok: false, resultado: { codigo: SALIDA.inesperado, json: { ok: false, error: "llavero_no_responde", message }, texto: message } };
     }
     if (vigente === null) {
-        const message = "Iniciá sesión con `supcoflow login`.";
+        const message = "Log in with `supcoflow login`.";
         return { ok: false, resultado: { codigo: SALIDA.faltaLogin, json: { ok: false, error: "sin_sesion", message }, texto: message } };
     }
     return { ok: true, vigente: { clave: vigente.clave, fuente: vigente.fuente, completa: lectura.completa } };