supcoflow 0.7.0 → 0.8.1

package/dist/pruebas-guardadas.js

@@ -14,27 +14,27 @@
 //
 // Estricto en todo, como `claves crear` en el registro de idempotencia: una prueba no tiene clave natural
 // del lado de la terminal, así que mandar sin el intento guardado arriesga una segunda prueba (que gasta).
-import path from "node:path";
 import { FalloDeLaTerminal, SALIDA } from "./contrato.js";
-import { dentroDeUnWorkingTree } from "./guardado/repo.js";
+import { SinProteccionDeGit } from "./guardado/protegido.js";
 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 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,42 +43,60 @@ 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`.
-        // No saber dónde cae (un enlace roto) es otro «no se puede guardar».
-        let raiz;
-        try {
-            raiz = dentroDeUnWorkingTree(path.dirname(d.rutaDelArchivo), d.fs);
-        }
-        catch {
-            throw noGuardada("resolver la ruta de");
-        }
-        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.`);
-        }
         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 (e) {
+            // El almacén protegido no escribe dentro de un repo si git no garantiza que lo deja afuera (fricción 2c):
+            // el mensaje dice qué archivo, qué repo y qué hacer.
+            if (e instanceof SinProteccionDeGit) {
+                throw new FalloDeLaTerminal(SALIDA.inesperado, "prueba_no_guardada", `I'm not saving the test request in ${d.rutaDelArchivo}; without saving it I won't send it. ${e.message}`);
+            }
+            throw noGuardada("save to");
+        }
+    }
+    async function revisar(proyectoId) {
+        const impedimentos = [];
+        try {
+            impedimentos.push(...(await d.revisarElLugar?.() ?? []));
+        }
+        catch {
+            impedimentos.push({ codigo: "no_se_pudo_revisar", detalle: `I couldn't check whether ${d.rutaDelArchivo} can be saved.` });
+        }
+        let intentoPendiente = null;
+        try {
+            const { intento } = await leer(proyectoId);
+            if (intento !== null)
+                intentoPendiente = { techoUsd: intento.techoUsd, politica: intento.politicaEsperada };
+        }
         catch {
-            throw noGuardada("guardar en");
+            impedimentos.push({ codigo: "archivo_ilegible", detalle: `I can't read or understand ${d.rutaDelArchivo}.` });
         }
+        return { maquina: { ok: impedimentos.length === 0, impedimentos }, intentoPendiente };
     }
     return {
         leer,
+        revisar,
         async abrir(proyectoId, intento) {
             const antes = await leer(proyectoId);
             await escribir(proyectoId, { intento, ultima: antes.ultima });

package/dist/repo-local.js

@@ -30,6 +30,52 @@ export function repoDelOrigin(url) {
     }
     return null;
 }
+// El `origin` con forma de alias de SSH (`git@github-gf0:dueño/repo`, `ssh://git@github-gf0/dueño/repo`): el host no
+// es github.com, pero el dueño/repo sí tiene la forma de uno de GitHub. NO se resuelve (no se corre `ssh` ni se lee su
+// configuración: `Match exec` ejecutaría programas de la persona): sólo se le dice qué asociar a mano, una vez.
+const FORMAS_DE_ALIAS = [
+    /^[A-Za-z0-9._-]+@([A-Za-z0-9._-]+):([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+    /^ssh:\/\/[A-Za-z0-9._-]+@([A-Za-z0-9._-]+)(?::\d+)?\/([^/\s]+)\/([^/\s]+?)(?:\.git)?\/?$/,
+];
+export function aliasDelOrigin(url) {
+    const limpia = url.trim();
+    for (const forma of FORMAS_DE_ALIAS) {
+        const m = forma.exec(limpia);
+        if (!m)
+            continue;
+        const repo = `${m[2]}/${m[3]}`;
+        if (m[1].toLowerCase() === "github.com" || !esRepoValido(repo))
+            return null;
+        return { host: m[1], repo };
+    }
+    return null;
+}
+// Lo que se muestra de un `origin`: nunca el usuario:clave@ de una URL (podría ser un token). Las credenciales se quitan de la
+// URL ENTERA y recién después se limita el tamaño (recortar antes dejaría pasar un `@` lejano con su clave a medias). Lo que no se
+// puede interpretar con seguridad no se muestra crudo: sale un marcador neutro.
+const TOPE_DEL_ORIGEN_MOSTRADO = 200;
+export function origenParaMostrar(url) {
+    const limpia = url.trim();
+    const url_ = /^([A-Za-z][A-Za-z0-9+.-]*:\/\/)([^/\s]*)(.*)$/s.exec(limpia);
+    let mostrable = null;
+    if (url_) {
+        // La autoridad llega hasta la primera `/`; el usuario:clave es todo lo anterior al ÚLTIMO `@` de la autoridad.
+        const arroba = url_[2].lastIndexOf("@");
+        const usuario = arroba === -1 ? "" : url_[2].slice(0, arroba).split(":")[0];
+        const host = arroba === -1 ? url_[2] : url_[2].slice(arroba + 1);
+        mostrable = `${url_[1]}${usuario === "git" ? "git@" : ""}${host}${url_[3]}`;
+    }
+    else if (/^[A-Za-z0-9._-]+@[A-Za-z0-9._-]+:/.test(limpia)) {
+        mostrable = limpia; // `git@host:o/r`: el usuario de un scp no lleva clave
+    }
+    if (mostrable === null || /\s/.test(mostrable))
+        return "(an address I don't recognize)";
+    return mostrable.length > TOPE_DEL_ORIGEN_MOSTRADO ? mostrable.slice(0, TOPE_DEL_ORIGEN_MOSTRADO) + "…" : mostrable;
+}
+// El remoto de asociación explícita: la persona le dice una sola vez a qué repo de GitHub corresponde este clon cuando su
+// `origin` no es una dirección de GitHub (alias de SSH, otro servidor). Con las mismas formas estrictas de `origin`;
+// nunca se usa para traer nada.
+export const REMOTO_DE_ASOCIACION = "supcoflow";
 export async function leerRepoLocal(git, cwd) {
     const top = await git(["rev-parse", "--show-toplevel"], cwd);
     const raiz = top.codigo === 0 ? top.stdout.trim() : "";
@@ -37,32 +83,68 @@ export async function leerRepoLocal(git, cwd) {
         return { repo: null, raiz: null, motivo: "sin_git" };
     const origin = await git(["remote", "get-url", "origin"], cwd);
     const url = origin.codigo === 0 ? origin.stdout.trim() : "";
+    const repoDelOrigen = url ? repoDelOrigin(url) : null;
+    // Si `origin` es de GitHub, gana `origin`, como siempre.
+    if (repoDelOrigen)
+        return { repo: repoDelOrigen, raiz };
+    const asociado = await git(["remote", "get-url", REMOTO_DE_ASOCIACION], cwd);
+    const urlAsociada = asociado.codigo === 0 ? asociado.stdout.trim() : "";
+    const repoAsociado = urlAsociada ? repoDelOrigin(urlAsociada) : null;
+    if (repoAsociado)
+        return { repo: repoAsociado, raiz };
+    const alias = url ? aliasDelOrigin(url) : null;
+    const comun = { repo: null, raiz, ...(url ? { origen: origenParaMostrar(url) } : {}), ...(urlAsociada ? { hayRemotoSupcoflow: true } : {}) };
     if (!url)
-        return { repo: null, raiz, motivo: "sin_origin" };
-    const repo = repoDelOrigin(url);
-    if (!repo)
-        return { repo: null, raiz, motivo: "origin_no_es_github" };
-    return { repo, raiz };
+        return { ...comun, motivo: "sin_origin" };
+    if (alias)
+        return { ...comun, motivo: "origin_alias_ssh", alias };
+    return { ...comun, motivo: "origin_no_es_github" };
+}
+// El comando exacto que asocia este clon con un repo de GitHub. `add` si todavía no hay remoto `supcoflow`; `set-url` si
+// hay uno que no es una dirección de GitHub.
+export function comandoDeAsociacion(repo, hayRemoto) {
+    return `git remote ${hayRemoto ? "set-url" : "add"} ${REMOTO_DE_ASOCIACION} https://github.com/${repo}.git`;
 }
 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",
+    origin_alias_ssh: "the \"origin\" remote isn't a GitHub repo",
 };
+// La frase que dice la verdad sobre un clon que no se puede atar a `repo` (owner/repo de GitHub) y cómo atarlo.
+export function frasePorQueNoAtaClon(local, repo) {
+    if (local.motivo === "sin_git")
+        return "This folder isn't a git clone.";
+    const sugerido = repo ?? local.alias?.repo ?? null;
+    const como = sugerido === null ? ""
+        : ` If this is ${sugerido} on GitHub, tell me once: \`${comandoDeAsociacion(sugerido, local.hayRemotoSupcoflow === true)}\` (it's never fetched).`;
+    if (local.motivo === "origin_alias_ssh" && repo === null && local.alias) {
+        return `Your origin uses the SSH alias \`${local.alias.host}\`, which I don't resolve.${como}`;
+    }
+    const clon = local.origen ? `This clone is \`${local.origen}\`, which I can't tie to github.com${repo ? `/${repo}` : ""}.` : "This clone has no \"origin\" remote I can tie to GitHub.";
+    return `${clon}${como}`;
+}
 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
+        // La raíz sólo se da si el repo local reconocido es ESE repo: con otro, lo que se escriba en esta
         // carpeta (el archivo del proyecto) no le pertenece.
         const mismo = local.repo !== null && local.repo.toLowerCase() === d.flagRepo.toLowerCase();
-        return { repo: d.flagRepo, raiz: mismo ? local.raiz : null };
+        if (mismo)
+            return { repo: d.flagRepo, raiz: local.raiz };
+        // El mensaje de «no es tu clon» dice por qué, y deja el comando exacto para atarlo si la persona SABE que lo es.
+        const sinClon = local.repo !== null
+            ? `This clone is github.com/${local.repo}, not ${d.flagRepo}.`
+            : frasePorQueNoAtaClon(local, d.flagRepo);
+        return { repo: d.flagRepo, raiz: null, sinClon };
     }
     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";
+        const detalle = local.motivo === "origin_alias_ssh" ? ` ${frasePorQueNoAtaClon(local, null)}` : "";
+        throw new FalloDeLaTerminal(SALIDA.entradaInvalida, "sin_repo", `I couldn't find a GitHub repo here (${porque}).${detalle} 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.1",
   "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" },