supcoflow 0.7.0 → 0.8.0

package/dist/instalacion.js

@@ -1,4 +1,4 @@
-// `.supcoflow/instalacion.json` (bloque 6, decisión 3): con qué versiones se hizo la instalación, anotado en el
+// `.supcoflow/instalacion.json` (bloque 6, decisión 3; v2 en la 0.8.0): con qué versiones se hizo la instalación, anotado en el
 // repo de quien instala. Supcoflow no lo guarda ni lo ve. Puro: recibe lo ya leído y arma el archivo.
 //
 // El archivo queda en el repo y se commitea: un secreto acá se publica con el primer `push`. Por eso se arma con
@@ -13,7 +13,7 @@ export const esSemver = (s) => s.length <= 64 && SEMVER.test(s);
 const objeto = (v) => (typeof v === "object" && v !== null && !Array.isArray(v) ? v : null);
 const entero = (v) => typeof v === "number" && Number.isInteger(v) && v >= 1;
 const ilegible = (message) => new FalloDeLaTerminal(SALIDA.inesperado, "paquete_ilegible", message);
-const inesperada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "configuracion_inesperada", `El motor contestó la configuración con ${que} que no entiendo; no anoto nada a medias. Probá de nuevo en un rato.`);
+const inesperada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "configuracion_inesperada", `The engine answered the configuration with ${que} I don't understand; I'm not recording anything halfway. Try again in a while.`);
 // Lo declarado en el `package.json` de la app lo escribió quien escribió el repo: puede ser un rango, un alias o
 // cualquier cosa. Se copia tal cual sólo si es texto imprimible y corto; si no, no se adivina (`paquete_ilegible`).
 // `taparSecretos` igual, por si alguien pegó una clave ahí: el archivo nuevo no la repite.
@@ -25,7 +25,7 @@ function declaradoEn(app) {
     if (v === undefined || v === null)
         return null;
     if (typeof v !== "string" || v.length === 0 || v.length > 200 || !/^[\x20-\x7e]+$/.test(v)) {
-        throw ilegible(`La versión de ${PAQUETE_DEL_CHAT} en el package.json de la app no se entiende; no la anoto.`);
+        throw ilegible(`The version of ${PAQUETE_DEL_CHAT} in the app's package.json isn't understandable; I'm not recording it.`);
     }
     return taparSecretos(v);
 }
@@ -35,7 +35,7 @@ function instaladoEn(paquete) {
         return null;
     const v = objeto(paquete)?.version;
     if (typeof v !== "string" || !esSemver(v))
-        throw ilegible(`El package.json de ${PAQUETE_DEL_CHAT} instalado no trae una versión que entienda.`);
+        throw ilegible(`The installed package.json of ${PAQUETE_DEL_CHAT} has no version I understand.`);
     return v;
 }
 function acuerdoDe(c) {
@@ -44,16 +44,16 @@ function acuerdoDe(c) {
     const a = objeto(c.acuerdo);
     // Ilegible es un estado conocido del motor (aplica cerrado), no «sin acuerdo»: anotarlo como null mentiría.
     if (a?.ilegible === true) {
-        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, "acuerdo_ilegible", "El acuerdo de datos está fijado pero no se lee: revisalo en la consola y volvé a correr.");
+        throw new FalloDeLaTerminal(SALIDA.haceFaltaUnaPersona, "acuerdo_ilegible", "The data agreement is set but can't be read: check it in the console and run again.");
     }
     if (a === null || !entero(a.version))
-        throw inesperada("un acuerdo");
+        throw inesperada("an agreement");
     return a.version;
 }
 function politicaDe(c) {
     const modo = objeto(c.politica)?.modo;
     if (modo !== "relevar" && modo !== "guardar")
-        throw inesperada("una política");
+        throw inesperada("a policy");
     return modo;
 }
 function guiaDe(c) {
@@ -62,24 +62,63 @@ function guiaDe(c) {
     const g = objeto(c.guia);
     if (g?.origen === "repo") {
         if (g.procedencia !== "terminal" && g.procedencia !== "github")
-            throw inesperada("una guía");
+            throw inesperada("a guide");
         if (g.commit !== null && (typeof g.commit !== "string" || !/^[0-9a-f]{40}$/.test(g.commit)))
-            throw inesperada("una guía");
+            throw inesperada("a guide");
         return { origen: "repo", procedencia: g.procedencia, commit: g.commit };
     }
     if (g?.origen === "agente" && entero(g.version))
         return { origen: "agente", version: g.version };
-    throw inesperada("una guía");
+    throw inesperada("a guide");
 }
 export function armarInstalacion(i) {
     return {
-        version: 1,
+        version: 2,
         skill: i.skill,
         terminal: i.terminal,
         chat: { declarado: declaradoEn(i.paqueteDeLaApp), instalado: instaladoEn(i.paqueteInstalado) },
         configuracion: { acuerdo_version: acuerdoDe(i.configuracion), politica: politicaDe(i.configuracion), guia: guiaDe(i.configuracion) },
+        archivo: i.archivo ?? null,
     };
 }
+// ─── El archivo del chat (`install record --file`) ───
+const MAX_LARGO_DEL_ARCHIVO = 300;
+// Pura: una ruta RELATIVA a la raíz del repo, sin `..`, sin ruta absoluta. Se devuelve normalizada (separador `/`, sin
+// `./` ni barras de más), que es como queda anotada. Que no sea un enlace simbólico lo mira el comando, con el disco.
+export function validarElArchivoDelChat(crudo) {
+    if (crudo.length === 0 || crudo.length > MAX_LARGO_DEL_ARCHIVO || /[\u0000-\u001f\u007f]/.test(crudo)) {
+        return { ok: false, motivo: `--file goes with a path of up to ${MAX_LARGO_DEL_ARCHIVO} printable characters.` };
+    }
+    if (crudo.startsWith("/") || crudo.startsWith("\\") || /^[A-Za-z]:/.test(crudo)) {
+        return { ok: false, motivo: "--file is a path relative to the repo root, not an absolute one." };
+    }
+    const partes = crudo.split(/[\\/]/).filter((x) => x !== "" && x !== ".");
+    if (partes.includes(".."))
+        return { ok: false, motivo: "--file can't go out of the repo: no `..` in the path." };
+    if (partes.length === 0)
+        return { ok: false, motivo: "--file is the chat file, not a folder: say its path." };
+    return { ok: true, ruta: partes.join("/") };
+}
+/** El `archivo` anotado en un `instalacion.json` ya existente: v1 y cualquier cosa ilegible o inválida dan null (nunca un error). */
+export function archivoAnotado(texto) {
+    if (texto === null)
+        return null;
+    let v;
+    try {
+        v = JSON.parse(texto);
+    }
+    catch {
+        return null;
+    }
+    // AD9: un v1 se reconoce por `version: 1` (lo escribe la terminal 0.7.0) y no tiene archivo, aunque el campo aparezca.
+    if (objeto(v)?.version === 1)
+        return null;
+    const a = objeto(v)?.archivo;
+    if (typeof a !== "string")
+        return null;
+    const r = validarElArchivoDelChat(a);
+    return r.ok && r.ruta === a ? a : null;
+}
 // El orden de las claves es el de `armarInstalacion`: el mismo estado da los mismos bytes, y eso es `sin_cambios`.
 export function serializar(x) {
     return JSON.stringify(x, null, 2) + "\n";

package/dist/lectura.js

@@ -0,0 +1,10 @@
+// Por qué `leerArchivoChico` no pudo leer un archivo. Son frases sueltas que van después de «I can't read X:», y
+// los comandos comparan contra estas constantes (nunca contra el texto a mano).
+export const NO_LEIDO = {
+    noExiste: "it doesn't exist",
+    esUnEnlace: "it's a symlink",
+    noSePudoAbrir: "it couldn't be opened",
+    noEsComun: "it isn't a regular file",
+    demasiadoGrande: "it's too large",
+    noSePudoLeer: "it couldn't be read",
+};

package/dist/pruebas-guardadas.js

@@ -21,20 +21,21 @@ function esIntento(v) {
     if (typeof v !== "object" || v === null)
         return false;
     const i = v;
-    return typeof i.clave === "string" && i.clave.length > 0 && (i.mensaje === null || typeof i.mensaje === "string") && typeof i.techo_usd === "number";
+    const politica = i.politica_esperada === undefined || i.politica_esperada === null || i.politica_esperada === "relevar" || i.politica_esperada === "guardar";
+    return typeof i.clave === "string" && i.clave.length > 0 && (i.mensaje === null || typeof i.mensaje === "string") && typeof i.techo_usd === "number" && politica;
 }
 export function crearRegistroDePruebas(d) {
     // Por origen, como la clave y el registro de idempotencia: un motor local (o el proxy de P4) y
     // producción no comparten intentos. Cambiar de origen entre dos comandos es otra clave.
     const cuenta = (proyectoId) => `${d.origen}#prueba#${proyectoId}`;
-    const noGuardada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `No pude ${que} ${d.rutaDelArchivo}; sin eso, un reintento podría pedir otra prueba (y gastar dos veces). Revisá ese archivo (no puede estar dentro de un repo) y probá de nuevo.`);
+    const noGuardada = (que) => new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I couldn't ${que} ${d.rutaDelArchivo}; without that, a retry could ask for another test (and spend twice). Check that file (it can't be inside a repo) and try again.`);
     async function leer(proyectoId) {
         let crudo;
         try {
             crudo = (await d.almacen.leer(cuenta(proyectoId)))?.valor ?? null;
         }
         catch {
-            throw noGuardada("leer");
+            throw noGuardada("read");
         }
         if (crudo === null)
             return { intento: null, ultima: null };
@@ -43,15 +44,18 @@ export function crearRegistroDePruebas(d) {
             v = JSON.parse(crudo);
         }
         catch {
-            throw noGuardada("entender");
+            throw noGuardada("understand");
         }
         const o = (typeof v === "object" && v !== null ? v : {});
         const intentoOk = o.intento === null || esIntento(o.intento);
         const ultimaOk = o.ultima === null || typeof o.ultima === "string";
         if (!intentoOk || !ultimaOk)
-            throw noGuardada("entender");
+            throw noGuardada("understand");
         const i = o.intento;
-        return { intento: i === null ? null : { clave: i.clave, mensaje: i.mensaje, techoUsd: i.techo_usd }, ultima: o.ultima };
+        return {
+            intento: i === null ? null : { clave: i.clave, mensaje: i.mensaje, techoUsd: i.techo_usd, politicaEsperada: i.politica_esperada ?? null },
+            ultima: o.ultima,
+        };
     }
     async function escribir(proyectoId, g) {
         // Misma regla que las credenciales: un destino dentro de un repo se publicaría con un `git add -A`.
@@ -61,20 +65,22 @@ export function crearRegistroDePruebas(d) {
             raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
         }
         catch {
-            throw noGuardada("resolver la ruta de");
+            throw noGuardada("resolve the path of");
         }
         if (raiz !== null) {
-            throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `No guardo el pedido de la prueba dentro de un repo de git (${raiz}); sin guardarlo no lo mando. Apuntá XDG_CONFIG_HOME fuera de un repo.`);
+            throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I'm not saving the test request inside a git repo (${raiz}); without saving it I won't send it. Point XDG_CONFIG_HOME outside a repo.`);
         }
         const valor = JSON.stringify({
-            intento: g.intento === null ? null : { clave: g.intento.clave, mensaje: g.intento.mensaje, techo_usd: g.intento.techoUsd },
+            intento: g.intento === null
+                ? null
+                : { clave: g.intento.clave, mensaje: g.intento.mensaje, techo_usd: g.intento.techoUsd, politica_esperada: g.intento.politicaEsperada },
             ultima: g.ultima,
         });
         try {
             await d.almacen.escribir(cuenta(proyectoId), { valor, escritoEn: d.ahora() });
         }
         catch {
-            throw noGuardada("guardar en");
+            throw noGuardada("save to");
         }
     }
     return {

package/dist/repo-local.js

@@ -45,15 +45,15 @@ export async function leerRepoLocal(git, cwd) {
     return { repo, raiz };
 }
 const MOTIVOS = {
-    sin_git: "esta carpeta no es un repo de git",
-    sin_origin: "el repo no tiene un remoto «origin»",
-    origin_no_es_github: "el «origin» no es un repo de GitHub",
+    sin_git: "this folder isn't a git repo",
+    sin_origin: "the repo has no remote called \"origin\"",
+    origin_no_es_github: "the \"origin\" remote isn't a GitHub repo",
 };
 export async function repoPedido(d) {
     const local = await leerRepoLocal(d.git, d.cwd);
     if (d.flagRepo !== null) {
         if (!esRepoValido(d.flagRepo)) {
-            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "El valor de --repo tiene que ser owner/repo (por ejemplo duenio/mi-app), sin la URL.");
+            throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "repo_invalido", "The value of --repo must be owner/repo (for example owner/my-app), without the URL.");
         }
         // La raíz sólo se da si el origin local es ESE repo: con otro, lo que se escriba en esta
         // carpeta (el archivo del proyecto) no le pertenece.
@@ -61,8 +61,8 @@ export async function repoPedido(d) {
         return { repo: d.flagRepo, raiz: mismo ? local.raiz : null };
     }
     if (local.repo === null) {
-        const porque = local.motivo ? MOTIVOS[local.motivo] : "no se pudo leer";
-        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `No encontré un repo de GitHub acá (${porque}). Pasá --repo owner/repo.`);
+        const porque = local.motivo ? MOTIVOS[local.motivo] : "the folder couldn't be read";
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}). Pass --repo owner/repo.`);
     }
     return { repo: local.repo, raiz: local.raiz };
 }

package/dist/secreto-a-archivo.js

@@ -22,7 +22,7 @@ import { dentroDeUnWorkingTree } from "./guardado/repo.js";
 // Una clave ocupa 85 caracteres: 4 KB es de sobra, y algo más grande ya no es una clave.
 const TOPE = 4 * 1024;
 const CLAVE = /^scf_([0-9a-f]{16})_[0-9a-f]{64}$/;
-const OCUPADO = { error: "el archivo ya tiene otra cosa; borralo o elegí otro destino", codigo: 4 };
+const OCUPADO = { error: "the file already has something else; delete it or pick another destination", codigo: 4 };
 export function crearGuardaDeSecretos(fs) {
     function borrarTemporal(tmp) {
         try {
@@ -50,10 +50,10 @@ export function crearGuardaDeSecretos(fs) {
             raiz = dentroDeUnWorkingTree(path.dirname(destino), fs);
         }
         catch {
-            return { error: "no pude resolver la ruta real de la carpeta (¿un enlace roto?)", codigo: 3 };
+            return { error: "I couldn't resolve the folder's real path (a broken link?)", codigo: 3 };
         }
         if (raiz !== null)
-            return { error: `cae dentro del repo de git ${raiz}, y una clave en un repo termina commiteada; elegí un destino fuera`, codigo: 3 };
+            return { error: `it falls inside the git repo ${raiz}, and a key in a repo ends up committed; pick a destination outside it`, codigo: 3 };
         return null;
     }
     return {
@@ -67,7 +67,7 @@ export function crearGuardaDeSecretos(fs) {
                 return invalido;
             const hay = fs.leerSinSeguir(destino, TOPE);
             if (hay.tipo === "enlace")
-                return { error: "el destino es un enlace; elegí un archivo común", codigo: 3 };
+                return { error: "the destination is a symlink; pick a regular file", codigo: 3 };
             if (hay.tipo !== "ausente") {
                 const actual = leer(destino);
                 if (actual.estado !== "clave" || actual.claveId !== claveId)
@@ -90,7 +90,7 @@ export function crearGuardaDeSecretos(fs) {
             catch {
                 // El mensaje del sistema no se reenvía: podría traer la ruta del temporal o algo peor.
                 borrarTemporal(tmp);
-                return { error: "no se pudo escribir ahí (¿la carpeta existe y tenés permiso?)", codigo: 3 };
+                return { error: "it couldn't be written there (does the folder exist, and do you have permission?)", codigo: 3 };
             }
             // Después de publicar, el temporal es un nombre de más (con `link`) o ya no existe (con `rename`): no
             // borrarlo no cambia que la clave quedó en el destino, y convertir eso en un fallo dejaría una clave
@@ -101,7 +101,7 @@ export function crearGuardaDeSecretos(fs) {
                 return OCUPADO;
             // Sin caer a `rename`: eso reabre la carrera que `link` cierra. Otro destino, en otro disco, sirve.
             if (publicado === "sin_enlaces") {
-                return { error: "el disco de esa carpeta no admite enlaces duros (¿FAT, exFAT o una carpeta de red?), y sin ellos no puedo escribir sin riesgo de pisar otra clave; elegí un destino en otro disco", codigo: 3 };
+                return { error: "that folder's disk doesn't support hard links (FAT, exFAT or a network folder?), and without them I can't write without risking overwriting another key; pick a destination on another disk", codigo: 3 };
             }
             return "guardado";
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "supcoflow",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "La terminal de Supcoflow: iniciar sesión y manejar el chat de soporte desde la consola o un asistente.",
   "type": "module",
   "bin": { "supcoflow": "dist/cli.js" },