supcoflow 0.7.0 → 0.8.1

package/dist/comandos/claves.js

@@ -13,12 +13,12 @@ const OPERACION = "clave_crear";
 const SUFIJO = /^scf_([0-9a-f]{16})_[0-9a-f]{64}$/;
 const ID_DE_CLAVE = /^cla_[0-9a-f]{16}$/;
 export async function clavesCrear(d, flags) {
-    if (flags.guardarEn === null)
-        return fallo(SALIDA.entradaInvalida, "falta_guardar_en", "Decí dónde guardar la clave: `supcoflow claves crear --nombre ci --guardar-en ~/ci.key` (fuera de un repo).");
-    if (flags.nombre === null)
-        return fallo(SALIDA.entradaInvalida, "falta_nombre", "Poné un nombre que diga para qué es: `--nombre ci`.");
+    if (flags.saveTo === null)
+        return fallo(SALIDA.entradaInvalida, "falta_guardar_en", "Say where to save the key: `supcoflow keys create --name ci --save-to ~/ci.key` (outside a repo).");
+    if (flags.name === null)
+        return fallo(SALIDA.entradaInvalida, "falta_nombre", "Give it a name that says what it's for: `--name ci`.");
     // Absoluta desde ya: la salida dice dónde quedó sin depender de dónde estaba parado el comando.
-    const destino = path.resolve(d.cwd, flags.guardarEn);
+    const destino = path.resolve(d.cwd, flags.saveTo);
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
         return p.resultado;
@@ -28,8 +28,8 @@ export async function clavesCrear(d, flags) {
     if (invalido !== null)
         return fallo(invalido.codigo, "destino_invalido", `${destino}: ${invalido.error}.`);
     if (flags.dryRun)
-        return dryRun(`POST ${ruta} y después …/confirmar`);
-    const alcance = `${p.proyecto.id}#${flags.nombre}`;
+        return dryRun(`POST ${ruta} and then …/confirmar`);
+    const alcance = `${p.proyecto.id}#${flags.name}`;
     // El registro de idempotencia pone el alcance en minúsculas (`CI` y `ci` comparten fila): el candado
     // tiene que coincidir, o dos procesos con la misma clave de reintento corrían a la vez.
     // 1. El candado: el ciclo entero, de a uno por operación en esta máquina. Comprobar que el archivo
@@ -38,18 +38,18 @@ export async function clavesCrear(d, flags) {
     // máquinas no comparten la clave de idempotencia, así que crean filas distintas y no se pisan.
     const candado = d.candados.tomar(`${OPERACION}#${alcance.toLowerCase()}`);
     if (candado.tipo === "ocupado")
-        return fallo(SALIDA.inesperado, "en_curso", "Otro `supcoflow claves crear` igual está corriendo en esta máquina; esperá a que termine.");
+        return fallo(SALIDA.inesperado, "en_curso", "Another identical `supcoflow keys create` is running on this machine; wait for it to finish.");
     if (candado.tipo === "abandonado") {
-        return fallo(SALIDA.inesperado, "candado_abandonado", `Quedó el candado de un \`claves crear\` que no terminó: ${candado.ruta}. Si no hay otro corriendo, borralo y volvé a probar.`);
+        return fallo(SALIDA.inesperado, "candado_abandonado", `A lock from a \`keys create\` that didn't finish was left behind: ${candado.ruta}. If nothing else is running, delete it and try again.`);
     }
     if (candado.tipo === "no_disponible") {
-        return fallo(SALIDA.inesperado, "candado_no_disponible", `No pude crear el candado en ${candado.ruta} (¿permisos?). Revisá esa carpeta y volvé a probar.`);
+        return fallo(SALIDA.inesperado, "candado_no_disponible", `I couldn't create the lock at ${candado.ruta} (permissions?). Check that folder and try again.`);
     }
     try {
         const autentica = async (secreto) => d.esClaveDeConsultaDelProyecto(d.api, secreto, p.proyecto.id);
         const yaCreada = async (claveId) => {
             await d.idempotencia.olvidar(OPERACION, alcance);
-            return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, archivo: destino, ya_confirmada: true }, texto: `La clave ${claveId} ya estaba creada; está en ${destino}.` };
+            return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, archivo: destino, ya_confirmada: true }, texto: `Key ${claveId} was already created; it's in ${destino}.` };
         };
         // 2. Mirar el destino antes de pedir nada. Una clave de consulta de ESTE proyecto que autentica es un
         // éxito anterior: repetir el comando no crea otra fila (el archivo es la referencia durable; la clave
@@ -60,12 +60,12 @@ export async function clavesCrear(d, flags) {
         if (hay.estado === "clave" && (await autentica(hay.secreto)))
             return await yaCreada(hay.claveId);
         if (hay.estado !== "ausente" && !(hay.estado === "clave" && (await d.idempotencia.tiene(OPERACION, alcance)))) {
-            return fallo(SALIDA.haceFaltaUnaPersona, "destino_ocupado", `${destino} ya tiene algo que no es una clave vigente de este proyecto; no lo toco. Borrá el archivo o elegí otro destino con --guardar-en.`);
+            return fallo(SALIDA.haceFaltaUnaPersona, "destino_ocupado", `${destino} already has something that isn't a current key for this project; I'm not touching it. Delete the file or pick another destination with --save-to.`);
         }
         // 3. El ciclo. Estricta: sin la clave de reintento guardada no se manda nada (Review Focus 15).
         const key = await d.idempotencia.claveDe(OPERACION, alcance, { estricta: true });
         for (let vuelta = 0; vuelta < 2; vuelta++) {
-            const r = await d.configurar(d.api, p.clave, ruta, { nombre: flags.nombre }, { idempotencyKey: key });
+            const r = await d.configurar(d.api, p.clave, ruta, { nombre: flags.name }, { idempotencyKey: key });
             if (r.status === 200 && r.cuerpo.estado === "activa") {
                 // El motor no rota una activa (no devuelve secreto): vale sólo si lo que tenemos es su secreto vigente.
                 const claveId = String(r.cuerpo.clave_id);
@@ -73,7 +73,7 @@ export async function clavesCrear(d, flags) {
                 if (ahora.estado === "clave" && ahora.claveId === claveId && (await autentica(ahora.secreto)))
                     return await yaCreada(claveId);
                 await d.idempotencia.olvidar(OPERACION, alcance);
-                return fallo(SALIDA.haceFaltaUnaPersona, "archivo_desactualizado", `La clave ${claveId} quedó activa, pero ${destino} no tiene su secreto vigente. Revocala con \`supcoflow claves revocar --id ${claveId}\` y creá otra.`);
+                return fallo(SALIDA.haceFaltaUnaPersona, "archivo_desactualizado", `Key ${claveId} is active, but ${destino} doesn't hold its current secret. Revoke it with \`supcoflow keys revoke --id ${claveId}\` and create another.`);
             }
             if (r.status !== 201) {
                 if (r.cuerpo.error === "clave_vencida") {
@@ -81,7 +81,7 @@ export async function clavesCrear(d, flags) {
                     await d.idempotencia.olvidar(OPERACION, alcance);
                     // El archivo conserva el secreto pendiente vencido y un reintento daría 4 destino_ocupado. Borrarlo
                     // desde acá sería tocar un archivo que quizá no escribió este run; se lo pedimos a la persona.
-                    return fallo(SALIDA.inesperado, "clave_vencida", `La clave pendiente venció sin confirmarse. Borrá ${destino} (guarda el secreto vencido, ya no sirve) y volvé a correr el comando para crear otra.`);
+                    return fallo(SALIDA.inesperado, "clave_vencida", `The pending key expired without being confirmed. Delete ${destino} (it holds the expired secret, which is no longer any use) and run the command again to create another.`);
                 }
                 // Misma clave de reintento con otro cuerpo: no se arregla reintentando, y guardada trabaría para siempre.
                 if (r.cuerpo.error === "idempotency_key_reusada")
@@ -91,25 +91,25 @@ export async function clavesCrear(d, flags) {
             const claveId = String(r.cuerpo.clave_id);
             const secreto = typeof r.cuerpo.clave === "string" && SUFIJO.test(r.cuerpo.clave) ? r.cuerpo.clave : null;
             if (secreto === null)
-                return fallo(SALIDA.inesperado, "respuesta_inesperada", "El motor no devolvió una clave con la forma esperada.");
+                return fallo(SALIDA.inesperado, "respuesta_inesperada", "The engine didn't return a key in the expected form.");
             // El id y el secreto tienen que ser de la misma fila: si no, lo que se guarda no es lo que se confirma.
             if (claveId !== `cla_${SUFIJO.exec(secreto)[1]}`)
-                return fallo(SALIDA.inesperado, "respuesta_inesperada", "El motor devolvió una clave que no corresponde a su id; no la guardé.");
+                return fallo(SALIDA.inesperado, "respuesta_inesperada", "The engine returned a key that doesn't match its id; I didn't save it.");
             const g = d.secretos.guardar(destino, claveId, secreto);
             // Sin guardarla NO se confirma: una pendiente sin confirmar no autentica y vence sola a los 10 minutos.
             if (g !== "guardado")
-                return fallo(g.codigo, "no_se_guardo", `No guardé la clave en ${destino}: ${g.error}. No quedó activa.`);
+                return fallo(g.codigo, "no_se_guardo", `I didn't save the key in ${destino}: ${g.error}. It was not activated.`);
             const c = await d.configurar(d.api, p.clave, `${ruta}/${encodeURIComponent(claveId)}/confirmar`, { clave: secreto });
             if (c.status === 200) {
                 await d.idempotencia.olvidar(OPERACION, alcance);
-                return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, archivo: destino }, texto: `Creé la clave de consulta ${claveId} y la guardé en ${destino}.` };
+                return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, archivo: destino }, texto: `Created read-only key ${claveId} and saved it in ${destino}.` };
             }
             // Obsoleta: otro intento con la misma clave de idempotencia le acuñó otro secreto a la misma fila.
             // Una vuelta más trae el vigente y lo guarda encima (mismo id).
             if (c.cuerpo.error !== "confirmacion_obsoleta")
                 return desenlace(c, () => { throw new Error("inalcanzable"); });
         }
-        return fallo(SALIDA.inesperado, "confirmacion_obsoleta", "Otro intento cambió la clave mientras la confirmaba; volvé a correr el comando.");
+        return fallo(SALIDA.inesperado, "confirmacion_obsoleta", "Another attempt changed the key while I was confirming it; run the command again.");
     }
     catch (e) {
         // Red caída a mitad, o el registro estricto que no pudo guardar: la clave de idempotencia (si llegó a
@@ -128,8 +128,8 @@ export async function clavesListar(d, flags) {
         // El motor ya manda sólo id, nombre y fecha (nunca el hash); acá se arma la forma pública igual.
         const claves = (await d.listarClaves(d.api, p.clave, p.proyecto.id)).map((c) => ({ id: c.id, nombre: c.nombre, creada_en: c.creadaEn }));
         const texto = claves.length === 0
-            ? "No hay claves de consulta activas."
-            : `Claves de consulta activas: ${claves.map((c) => `${c.id} (${c.nombre})`).join(", ")}.`;
+            ? "There are no active read-only keys."
+            : `Active read-only keys: ${claves.map((c) => `${c.id} (${c.nombre})`).join(", ")}.`;
         return { codigo: SALIDA.ok, json: { ok: true, claves }, texto };
     }
     catch (e) {
@@ -138,7 +138,7 @@ export async function clavesListar(d, flags) {
 }
 export async function clavesRevocar(d, flags) {
     if (flags.id === null || !ID_DE_CLAVE.test(flags.id)) {
-        return fallo(SALIDA.entradaInvalida, "id_invalido", "Decí qué clave revocar con su id: `supcoflow claves revocar --id cla_…` (lo da `supcoflow claves listar`).");
+        return fallo(SALIDA.entradaInvalida, "id_invalido", "Say which key to revoke by its id: `supcoflow keys revoke --id cla_…` (`supcoflow keys list` gives it).");
     }
     const claveId = flags.id;
     const p = await proyectoDelRepo(d, flags);
@@ -151,9 +151,9 @@ export async function clavesRevocar(d, flags) {
         const r = await d.configurar(d.api, p.clave, ruta, { clave_id: claveId });
         // Revocar dos veces deja lo mismo que una: para quien lo pide, ya está hecho.
         if (r.status === 409 && r.cuerpo.error === "ya_revocada") {
-            return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, ya_revocada: true }, texto: `La clave ${claveId} ya estaba revocada.` };
+            return { codigo: SALIDA.ok, json: { ok: true, clave_id: claveId, ya_revocada: true }, texto: `Key ${claveId} was already revoked.` };
         }
-        return desenlace(r, () => ({ codigo: SALIDA.ok, json: { ok: true, clave_id: claveId }, texto: `Revoqué la clave ${claveId}; deja de autenticar.` }));
+        return desenlace(r, () => ({ codigo: SALIDA.ok, json: { ok: true, clave_id: claveId }, texto: `Revoked key ${claveId}; it no longer authenticates.` }));
     }
     catch (e) {
         return resultadoDeFallo(e);

package/dist/comandos/configurar.js

@@ -14,12 +14,12 @@ export function desenlace(r, ok) {
     // Propio de esta función (hoy `conClave` ya lo filtra antes): sin esto, un 401 o un 5xx caerían en el 3 de
     // «entrada inválida» y la persona (o el asistente) corregiría una entrada que estaba bien.
     if (r.status === 401)
-        return fallo(SALIDA.faltaLogin, "clave_invalida", "La clave ya no vale: iniciá sesión de nuevo.");
+        return fallo(SALIDA.faltaLogin, "clave_invalida", "The key is no longer valid: log in again.");
     if (r.status >= 500 || typeof r.cuerpo !== "object" || r.cuerpo === null) {
-        return fallo(SALIDA.inesperado, "respuesta_inesperada", `El motor contestó algo que no entiendo (${r.status}); probá de nuevo en un rato.`);
+        return fallo(SALIDA.inesperado, "respuesta_inesperada", `The engine answered something I don't understand (${r.status}); try again in a while.`);
     }
     const error = typeof r.cuerpo.error === "string" ? r.cuerpo.error : "rechazado";
-    const message = taparSecretos(typeof r.cuerpo.message === "string" ? r.cuerpo.message : `El motor rechazó el pedido (${r.status}).`);
+    const message = taparSecretos(typeof r.cuerpo.message === "string" ? r.cuerpo.message : `The engine rejected the request (${r.status}).`);
     if (PIDEN_UNA_PERSONA.has(error))
         return fallo(SALIDA.haceFaltaUnaPersona, error, message);
     if (TRANSITORIOS.has(error))
@@ -27,7 +27,7 @@ export function desenlace(r, ok) {
     return fallo(SALIDA.entradaInvalida, error, message);
 }
 export const rutaDe = (p, resto) => `/api/proyectos/${encodeURIComponent(p.id)}${resto}`;
-export const dryRun = (haria) => ({ codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él: ${haria}.` });
+export const dryRun = (haria) => ({ codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` });
 export async function comandoConfiguracion(d, flags) {
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
@@ -41,18 +41,18 @@ export async function comandoConfiguracion(d, flags) {
         // promete «ninguna IA» ni «toda IA». `acuerdo` puede ser null, un acuerdo o {ilegible: true}.
         const ac = c.acuerdo;
         const acuerdo = ac === null || ac === undefined
-            ? "sin fijar (entra todo, como hoy)"
+            ? "not set (everything gets through, as today)"
             : ac.ilegible === true
-                ? "fijado pero ilegible (revisalo en la consola)"
-                : "fijado";
-        const alcance = ac === null || ac === undefined ? "" : " Frena lo que se guarda y lo que lee la IA que releva; no cubre lo que ve la IA del chat mientras conversa.";
+                ? "set but unreadable (check it in the console)"
+                : "set";
+        const alcance = ac === null || ac === undefined ? "" : " It limits what is saved and what the AI that investigates reads; it does not cover what the chat's AI sees while it talks.";
         return {
             codigo: SALIDA.ok,
             json: { ok: true, proyecto: p.proyecto.id, ...c },
             texto: [
-                `${p.proyecto.id}: chat ${chat.habilitado ? "prendido" : "apagado"}, ${sitiosLista.length} sitio(s), acuerdo de datos ${acuerdo}.${alcance}`,
-                `Política de problemas: ${textoDePolitica(c.politica)}`,
-                `Marca: ${textoDeMarca(c.marca)}`,
+                `${p.proyecto.id}: chat ${chat.habilitado ? "on" : "off"}, ${sitiosLista.length} site(s), data agreement ${acuerdo}.${alcance}`,
+                `Problem policy: ${textoDePolitica(c.politica)}`,
+                `Brand: ${textoDeMarca(c.marca)}`,
             ].join("\n"),
         };
     }
@@ -66,10 +66,10 @@ export async function comandoConfiguracion(d, flags) {
 function textoDePolitica(v) {
     const modo = v?.modo;
     if (modo === "relevar")
-        return "relevar: cada problema se releva y nace el issue (gasta).";
+        return "investigate: every problem is investigated and an issue is created (this costs money).";
     if (modo === "guardar")
-        return "guardar: los problemas del chat se guardan sin relevar; desde la consola una persona puede pedir el relevamiento (gasta).";
-    return "el motor no la informó.";
+        return "save: the chat's problems are saved without investigating; from the console a person can still ask for the investigation (this costs money).";
+    return "the engine didn't report it.";
 }
 // Título, saludo y tema los escribe quien configura el chat y llegan tal cual: un ESC en el título movería el
 // cursor o cambiaría colores en la terminal de quien corre `configuracion`. En texto se quitan los caracteres
@@ -79,21 +79,21 @@ const limpio = (t) => t.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
 // muestran las claves tal cual vinieron: el motor decide cuáles hay, la terminal no las reinterpreta.
 function textoDeMarca(v) {
     if (v === undefined)
-        return "el motor no la informó.";
+        return "the engine didn't report it.";
     if (v === null)
-        return "sin fijar (el chat usa la de fábrica).";
+        return "not set (the chat uses the default one).";
     const m = v;
     const partes = [];
     if (typeof m.titulo === "string" && m.titulo !== "")
-        partes.push(`título «${limpio(m.titulo)}»`);
+        partes.push(`title «${limpio(m.titulo)}»`);
     if (typeof m.saludo === "string" && m.saludo !== "")
-        partes.push(`saludo «${limpio(m.saludo)}»`);
+        partes.push(`greeting «${limpio(m.saludo)}»`);
     if (typeof m.tema === "object" && m.tema !== null) {
         const colores = Object.entries(m.tema).filter(([, x]) => typeof x === "string").map(([k, x]) => `${limpio(k)} ${limpio(x)}`);
         if (colores.length > 0)
-            partes.push(`tema ${colores.join(", ")}`);
+            partes.push(`theme ${colores.join(", ")}`);
     }
-    partes.push(typeof m.logo_url === "string" && m.logo_url !== "" ? "con logo" : "sin logo");
+    partes.push(typeof m.logo_url === "string" && m.logo_url !== "" ? "with logo" : "no logo");
     return partes.join(", ") + ".";
 }
 export async function chatPrenderApagar(d, flags, habilitar) {
@@ -104,35 +104,35 @@ export async function chatPrenderApagar(d, flags, habilitar) {
     if (flags.dryRun)
         return dryRun(`POST ${ruta} {habilitado: ${habilitar}}`);
     return desenlace(await d.configurar(d.api, p.clave, ruta, { habilitado: habilitar }), () => ({
-        codigo: SALIDA.ok, json: { ok: true, habilitado: habilitar }, texto: habilitar ? "Chat prendido." : "Chat apagado.",
+        codigo: SALIDA.ok, json: { ok: true, habilitado: habilitar }, texto: habilitar ? "Chat turned on." : "Chat turned off.",
     }));
 }
 export async function sitios(d, flags, accion) {
-    if (flags.sitio === null)
-        return fallo(SALIDA.entradaInvalida, "falta_sitio", `Falta el sitio: \`supcoflow sitios ${accion} --sitio https://tu-app.com\`.`);
+    if (flags.site === null)
+        return fallo(SALIDA.entradaInvalida, "falta_sitio", `The site is missing: \`supcoflow sites ${accion === "agregar" ? "add" : "remove"} --site https://your-app.com\`.`);
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
         return p.resultado;
     const ruta = rutaDe(p.proyecto, "/origenes");
     if (flags.dryRun)
         return dryRun(`POST ${ruta} {accion: ${accion}}`);
-    return desenlace(await d.configurar(d.api, p.clave, ruta, { accion, origen: flags.sitio }), (c) => ({
-        codigo: SALIDA.ok, json: { ok: true, sitios: c.origenes }, texto: `Sitios: ${c.origenes.join(", ") || "ninguno"}.`,
+    return desenlace(await d.configurar(d.api, p.clave, ruta, { accion, origen: flags.site }), (c) => ({
+        codigo: SALIDA.ok, json: { ok: true, sitios: c.origenes }, texto: `Sites: ${c.origenes.join(", ") || "none"}.`,
     }));
 }
 export async function chatMarca(d, flags) {
     const tema = {};
-    for (const t of flags.tema) {
+    for (const t of flags.theme) {
         const i = t.indexOf("=");
         if (i <= 0 || i === t.length - 1)
-            return fallo(SALIDA.entradaInvalida, "tema_invalido", `--tema va como clave=valor (por ejemplo acento=#0a7); recibí «${t}».`);
+            return fallo(SALIDA.entradaInvalida, "tema_invalido", `--theme goes as key=value (for example acento=#0a7); I got «${t}».`);
         const clave = t.slice(0, i);
         if (clave in tema)
-            return fallo(SALIDA.entradaInvalida, "tema_invalido", `--tema ${clave} va una sola vez.`);
+            return fallo(SALIDA.entradaInvalida, "tema_invalido", `--theme ${clave} can only be given once.`);
         tema[clave] = t.slice(i + 1);
     }
-    if (flags.titulo === null && flags.saludo === null && Object.keys(tema).length === 0) {
-        return fallo(SALIDA.entradaInvalida, "marca_vacia", "Pasá al menos --titulo, --saludo o --tema.");
+    if (flags.title === null && flags.greeting === null && Object.keys(tema).length === 0) {
+        return fallo(SALIDA.entradaInvalida, "marca_vacia", "Give at least one of --title, --greeting or --theme.");
     }
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
@@ -151,8 +151,8 @@ export async function chatMarca(d, flags) {
         return resultadoDeFallo(e);
     }
     const cuerpo = {};
-    const titulo = flags.titulo ?? (typeof actual?.titulo === "string" ? actual.titulo : null);
-    const saludo = flags.saludo ?? (typeof actual?.saludo === "string" ? actual.saludo : null);
+    const titulo = flags.title ?? (typeof actual?.titulo === "string" ? actual.titulo : null);
+    const saludo = flags.greeting ?? (typeof actual?.saludo === "string" ? actual.saludo : null);
     if (titulo !== null)
         cuerpo.titulo = titulo;
     if (saludo !== null)
@@ -164,24 +164,24 @@ export async function chatMarca(d, flags) {
     const ruta = rutaDe(p.proyecto, "/chat/marca");
     if (flags.dryRun)
         return dryRun(`POST ${ruta}`);
-    return desenlace(await d.configurar(d.api, p.clave, ruta, cuerpo), (c) => ({ codigo: SALIDA.ok, json: { ok: true, marca: c.marca }, texto: "Marca guardada." }));
+    return desenlace(await d.configurar(d.api, p.clave, ruta, cuerpo), (c) => ({ codigo: SALIDA.ok, json: { ok: true, marca: c.marca }, texto: "Brand saved." }));
 }
 const MIMES = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp" };
 // El tope del motor es 200 KB (`MAX_LOGO_BYTES`); acá se corta antes para no mandar de más. El motor decide.
 const TOPE_DEL_LOGO = 200_000;
 export async function chatLogo(d, flags) {
-    if (flags.archivo === null)
-        return fallo(SALIDA.entradaInvalida, "falta_archivo", "Falta el logo: `supcoflow chat logo --archivo logo.png`.");
-    const mime = MIMES[path.extname(flags.archivo).toLowerCase()];
+    if (flags.file === null)
+        return fallo(SALIDA.entradaInvalida, "falta_archivo", "The logo is missing: `supcoflow chat logo --file logo.png`.");
+    const mime = MIMES[path.extname(flags.file).toLowerCase()];
     if (mime === undefined)
-        return fallo(SALIDA.entradaInvalida, "logo_invalido", "El logo tiene que ser .png, .jpg o .webp.");
-    const leido = d.leerArchivoChico(flags.archivo, TOPE_DEL_LOGO);
+        return fallo(SALIDA.entradaInvalida, "logo_invalido", "The logo must be .png, .jpg or .webp.");
+    const leido = d.leerArchivoChico(flags.file, TOPE_DEL_LOGO);
     if ("error" in leido)
-        return fallo(SALIDA.entradaInvalida, "logo_ilegible", `No leo ${flags.archivo}: ${leido.error}.`);
+        return fallo(SALIDA.entradaInvalida, "logo_ilegible", `I can't read ${flags.file}: ${leido.error}.`);
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
         return p.resultado;
     if (flags.dryRun)
         return dryRun(`POST ${rutaDe(p.proyecto, "/chat/logo")} (${leido.bytes.length} bytes)`);
-    return desenlace(await d.subirLogo(d.api, p.clave, p.proyecto.id, { bytes: leido.bytes, mime, nombre: path.basename(flags.archivo) }), (c) => ({ codigo: SALIDA.ok, json: { ok: true, logo_url: c.logo_url }, texto: "Logo subido." }));
+    return desenlace(await d.subirLogo(d.api, p.clave, p.proyecto.id, { bytes: leido.bytes, mime, nombre: path.basename(flags.file) }), (c) => ({ codigo: SALIDA.ok, json: { ok: true, logo_url: c.logo_url }, texto: "Logo uploaded." }));
 }

package/dist/comandos/contexto.js

@@ -0,0 +1,102 @@
+// ¿Este repo va con la cuenta en la que estoy? (1A.1, fricción 6). La terminal junta lo que ya sabe y frena, ANTES de
+// conectar, crear o publicar nada, ante lo que no cierra y se puede VER:
+//   - el `.supcoflow/proyecto.json` del clon contra el proyecto que la clave ve para ese repo;
+//   - ese archivo cuando no se entiende;
+//   - al crear un proyecto: el dueño del repo contra el login de GitHub de la clave, y la falta de GitHub.
+// Qué NO cubre: un proyecto del mismo repo en OTRO equipo cuando el clon no tiene su archivo (el motor tendría que mirar
+// en todos los equipos y eso filtra información entre clientes), ni prueba una identidad: el motor compara el número de
+// GitHub y el login es una etiqueta que se puede cambiar. Por eso `dueno_distinto_del_login` es una posible incoherencia.
+import path from "node:path";
+import { SALIDA } from "../contrato.js";
+// Lo único que se lee de un `.supcoflow/proyecto.json` ajeno es su id, y sólo si tiene esta forma:
+// así lo que salga a la terminal no puede ser otra cosa que un id (Review Focus 11).
+const FORMA_DEL_ID = /^proj_[a-z0-9-]{1,80}$/;
+export const RUTA_DEL_ARCHIVO_DEL_CLON = path.join(".supcoflow", "proyecto.json");
+export function idDelArchivo(crudo) {
+    try {
+        const v = JSON.parse(crudo);
+        if (typeof v !== "object" || v === null)
+            return null;
+        const id = v.id;
+        return typeof id === "string" && FORMA_DEL_ID.test(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Los tres estados del archivo del clon. Nunca se imprime su contenido; sólo el id, si tiene forma de id. */
+export function leerElArchivoDelClon(archivos, raiz) {
+    // Sin clon de este repo (un `--repo` ajeno a la carpeta) no hay archivo que le pertenezca.
+    if (archivos === undefined || raiz === null)
+        return { estado: "ausente" };
+    let crudo;
+    try {
+        crudo = archivos.leer(path.join(raiz, RUTA_DEL_ARCHIVO_DEL_CLON));
+    }
+    catch {
+        return { estado: "ilegible" };
+    }
+    if (crudo === null)
+        return { estado: "ausente" };
+    const id = idDelArchivo(crudo);
+    return id === null ? { estado: "ilegible" } : { estado: "valido", id };
+}
+export function contextoIncoherente(motivo, message, extra = {}) {
+    return { codigo: SALIDA.haceFaltaUnaPersona, json: { ok: false, error: "contexto_incoherente", motivo, message, ...extra }, texto: message };
+}
+/**
+ * El clon contra lo que la clave ve (lo que comparten TODOS los comandos que actúan sobre el proyecto del repo).
+ * `null` = coherente. `proyecto` es el que la clave ve para este repo, o null si no ve ninguno.
+ */
+export function coherenciaDelClon(archivo, proyecto, repo) {
+    if (archivo.estado === "ilegible") {
+        return contextoIncoherente("archivo_del_clon_ilegible", "I can't read `.supcoflow/proyecto.json` in this clone; I won't act on this repo until it's readable. Look at it before going on.", { repo, en_el_clon: { estado: "ilegible", id: null } });
+    }
+    if (archivo.estado === "valido" && archivo.id !== proyecto?.id) {
+        return contextoIncoherente("proyecto_del_clon_distinto", `The project noted in this clone (${archivo.id}) isn't the one your account sees for this repo (${proyecto?.id ?? "none"}). `
+            + "Check which account you signed in with (`supcoflow whoami`), or, if that file is old, review it.", { repo, en_el_clon: { estado: "valido", id: archivo.id }, proyecto: proyecto?.id ?? null });
+    }
+    return null;
+}
+export function armarElContexto(d) {
+    const { yo } = d;
+    const soloLectura = yo.via === "clave_de_consulta";
+    const login = yo.usuario?.login ?? null;
+    const tipo = soloLectura ? "clave_de_consulta" : login !== null ? "github" : "email";
+    return {
+        equipo: yo.equipo,
+        identidad: tipo === "github" ? login : tipo,
+        identidad_tipo: tipo,
+        fuente: d.fuente,
+        repo: d.repo,
+        proyecto: d.proyecto?.id ?? null,
+        en_el_clon: { estado: d.archivo.estado, id: d.archivo.estado === "valido" ? d.archivo.id : null },
+    };
+}
+/** La línea que la persona lee: quién es, en qué equipo, qué repo y qué proyecto. */
+export function lineaDelContexto(c, readOnlyDe = null) {
+    const quien = c.identidad_tipo === "github" ? `@${c.identidad}` : c.identidad_tipo === "email" ? "signed in with email (no GitHub)" : `using a read-only key${readOnlyDe ? ` for ${readOnlyDe}` : ""}`;
+    const cuenta = `You're ${quien} in team ${c.equipo}`;
+    const proyecto = c.proyecto !== null ? `project ${c.proyecto} (existing)` : `no project yet (it will be created in team ${c.equipo})`;
+    return `${cuenta}; repo ${c.repo}; ${proyecto}.`;
+}
+/**
+ * Sólo cuando la clave NO ve proyecto para el repo y se va a crear uno: lo que se ve de la cuenta contra el repo.
+ * Una clave de consulta no crea nada, así que no se compara su login con nadie.
+ */
+export function coherenciaAlCrear(d) {
+    if (d.yo.via === "clave_de_consulta")
+        return null;
+    const login = d.yo.usuario?.login ?? null;
+    if (login === null) {
+        return contextoIncoherente("sin_github", "Connecting a repo needs a Supcoflow account signed in with GitHub.", { repo: d.repo });
+    }
+    const dueno = d.repo.split("/")[0];
+    if (dueno.toLowerCase() === login.toLowerCase())
+        return null;
+    const deLaVariable = d.fuente === "env"
+        ? " Your key comes from SUPCOFLOW_TOKEN, which wins over a new login: unset it or replace it first; I don't touch it."
+        : "";
+    return contextoIncoherente("dueno_distinto_del_login", `This repo's owner on GitHub (@${dueno}) isn't the GitHub account your key shows (@${login}). `
+        + `If you renamed your GitHub account, sign in to the Supcoflow console with GitHub again (that updates it) and run this again; otherwise sign in as @${dueno}.${deLaVariable}`, { repo: d.repo, dueno, login, ...(d.fuente === "env" ? { fuente: "env" } : {}) });
+}

package/dist/comandos/datos-y-politica.js

@@ -1,52 +1,63 @@
+import { PERMITIDOS_VIEJOS, PREFIJO_VIEJO_DE_ATRIBUTO } from "../alias.js";
 import { resultadoDeFallo, SALIDA } from "../contrato.js";
 import { claveVigente } from "./clave-vigente.js";
 import { desenlace } from "./configurar.js";
 import { proyectoDelRepo } from "./proyecto-del-repo.js";
-const BANDERAS = ["usuario_id", "usuario_rol", "pagina_y_navegador", "capturas", "elementos", "email"];
+// Los nombres de `--allow` son ingleses; a la API viaja el suyo (`Permitido`). Los castellanos de la 0.7.0 valen igual
+// (`src/alias.ts`).
+const DE_LA_API = { user_id: "usuario_id", user_role: "usuario_rol", page_and_browser: "pagina_y_navegador", screenshots: "capturas", elements: "elementos", email: "email" };
+const BANDERAS = Object.keys(DE_LA_API);
+const PREFIJO_DEL_ATRIBUTO = "attribute:";
 // Los límites del contrato (`Permitido.atributos`: ≤ 8, 1–40 caracteres). Se cortan acá para que un
-// --permitir imposible salga 3 sin pedido; el motor sigue siendo quien decide.
+// --allow imposible salga 3 sin pedido; el motor sigue siendo quien decide.
 const MAX_ATRIBUTOS = 8;
 const MAX_LARGO_DE_ATRIBUTO = 40;
 const fallo = (codigo, error, message) => ({ codigo, json: { ok: false, error, message }, texto: message });
 const rutaDe = (p, resto) => `/api/proyectos/${encodeURIComponent(p.id)}${resto}`;
-const dryRun = (haria) => ({ codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él: ${haria}.` });
+const dryRun = (haria) => ({ codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` });
+// Lleva un valor de `--allow` (nuevo o viejo) a su forma inglesa canónica.
+function aInglesElPermitido(x) {
+    if (x.startsWith(PREFIJO_VIEJO_DE_ATRIBUTO))
+        return PREFIJO_DEL_ATRIBUTO + x.slice(PREFIJO_VIEJO_DE_ATRIBUTO.length);
+    return PERMITIDOS_VIEJOS[x] ?? x;
+}
 export function leerPermitir(crudo) {
-    const partes = crudo.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    const partes = crudo.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map(aInglesElPermitido);
     const p = { usuario_id: false, usuario_rol: false, atributos: [], pagina_y_navegador: false, capturas: false, elementos: false, email: false };
-    if (partes.length === 1 && partes[0] === "nada")
+    if (partes.length === 1 && partes[0] === "nothing")
         return p;
-    if (partes.length === 0 || partes.includes("nada"))
-        return { error: "`nada` va solo; si no, nombrá lo que sí pasa." };
+    if (partes.length === 0 || partes.includes("nothing"))
+        return { error: "`nothing` goes alone; otherwise, name what does get through." };
     const vistos = new Set();
     for (const x of partes) {
         if (vistos.has(x))
-            return { error: `«${x}» está repetido.` };
+            return { error: `«${x}» is repeated.` };
         vistos.add(x);
-        if (x.startsWith("atributo:")) {
+        if (x.startsWith(PREFIJO_DEL_ATRIBUTO)) {
             // Recortado: « plan» y «plan» son el mismo atributo para quien lo escribe, y el motor lo compara exacto.
-            const nombre = x.slice("atributo:".length).trim();
+            const nombre = x.slice(PREFIJO_DEL_ATRIBUTO.length).trim();
             if (nombre.length === 0)
-                return { error: "`atributo:` va con el nombre exacto del atributo, por ejemplo atributo:plan." };
+                return { error: "`attribute:` goes with the attribute's exact name, for example attribute:plan." };
             if (nombre.length > MAX_LARGO_DE_ATRIBUTO)
-                return { error: `El nombre de un atributo tiene hasta ${MAX_LARGO_DE_ATRIBUTO} caracteres.` };
+                return { error: `An attribute's name has up to ${MAX_LARGO_DE_ATRIBUTO} characters.` };
             if (p.atributos.length >= MAX_ATRIBUTOS)
-                return { error: `Hasta ${MAX_ATRIBUTOS} atributos.` };
+                return { error: `Up to ${MAX_ATRIBUTOS} attributes.` };
             p.atributos.push(nombre);
         }
         else if (BANDERAS.includes(x)) {
-            p[x] = true;
+            p[DE_LA_API[x]] = true;
         }
         else {
-            return { error: `No conozco «${x}». Valen: ${BANDERAS.join(", ")}, atributo:<nombre>, o nada.` };
+            return { error: `I don't know «${x}». Valid: ${BANDERAS.join(", ")}, attribute:<name>, or nothing.` };
         }
     }
     return p;
 }
 export async function datosFijar(d, flags) {
-    if (flags.permitir === null) {
-        return fallo(SALIDA.entradaInvalida, "falta_permitir", "Falta qué datos pasan: `supcoflow datos fijar --permitir usuario_id,capturas` (o `--permitir nada`).");
+    if (flags.allow === null) {
+        return fallo(SALIDA.entradaInvalida, "falta_permitir", "Say which data gets through: `supcoflow data set --allow user_id,screenshots` (or `--allow nothing`).");
     }
-    const permitido = leerPermitir(flags.permitir);
+    const permitido = leerPermitir(flags.allow);
     if ("error" in permitido)
         return fallo(SALIDA.entradaInvalida, "permitir_invalido", permitido.error);
     const p = await proyectoDelRepo(d, flags);
@@ -69,15 +80,16 @@ export async function datosFijar(d, flags) {
         return {
             codigo: SALIDA.ok,
             json: { ok: true, acuerdo: c.acuerdo, alcance: "guardado_y_relevamiento" },
-            texto: `Acuerdo de datos fijado (versión ${version}). Frena lo que se guarda y lo que lee la IA que releva; no lo que ve la IA del chat mientras conversa.`,
+            texto: `Data agreement set (version ${version}). It limits what is saved and what the AI that investigates reads; not what the chat's AI sees while it talks.`,
         };
     });
 }
 export async function politicaFijar(d, flags) {
-    if (flags.modo !== "relevar" && flags.modo !== "guardar") {
-        return fallo(SALIDA.entradaInvalida, "modo_invalido", "--modo vale `relevar` o `guardar`: `supcoflow politica fijar --modo guardar`.");
+    // A la API viaja `relevar` / `guardar`; `investigate` / `save` son sus nombres ingleses.
+    const modo = flags.mode === "investigate" || flags.mode === "relevar" ? "relevar" : flags.mode === "save" || flags.mode === "guardar" ? "guardar" : null;
+    if (modo === null) {
+        return fallo(SALIDA.entradaInvalida, "modo_invalido", "--mode is `investigate` or `save`: `supcoflow policy set --mode save`.");
     }
-    const modo = flags.modo;
     const p = await proyectoDelRepo(d, flags);
     if (!p.ok)
         return p.resultado;
@@ -94,7 +106,7 @@ export async function politicaFijar(d, flags) {
     return desenlace(r, (c) => ({
         codigo: SALIDA.ok,
         json: { ok: true, politica: c.politica },
-        texto: `Política de problemas fijada: ${modo}.`,
+        texto: `Problem policy set: ${modo === "relevar" ? "investigate" : "save"}.`,
     }));
 }
 export async function comandoCatalogo(d) {