supcoflow 0.7.0 → 0.8.0

package/dist/comandos/login.js

@@ -1,7 +1,8 @@
 import { FalloDeLaTerminal, resultadoDeFallo, SALIDA, taparSecretos } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { PLAZO_MINIMO_MS, RESERVA_PARA_CERRAR_MS, sondearUnTramo, TRAMO_MAXIMO_MS } from "../sondeo.js";
 const TECHO_DE_UN_PASO_MS = 5_000;
-const VOLVER_A_EMPEZAR = "Volvé a empezar con `supcoflow login --start`.";
+const VOLVER_A_EMPEZAR = "Start over with `supcoflow login --start`.";
 const fallo = (codigo, error, message, extra = {}) => ({
     codigo, json: { ok: false, error, message, ...extra }, texto: message,
 });
@@ -12,7 +13,7 @@ const motivo = (e) => e instanceof FalloDeLaTerminal ? e.message : taparSecretos
 export async function reintentarPorRevocar(d, limite) {
     const origen = d.api.origin;
     const noSe = () => {
-        d.avisar("No pude leer entera la lista de claves por revocar (el llavero no respondió); la reintento la próxima vez.");
+        d.avisar("I couldn't read the whole list of keys waiting to be revoked (the keychain didn't respond); I'll try again next time.");
     };
     let lectura;
     try {
@@ -54,8 +55,8 @@ export async function reintentarPorRevocar(d, limite) {
 export async function loginStart(d, flags) {
     const origen = d.api.origin;
     if (flags.dryRun) {
-        const haria = `pedir un código de dispositivo a ${origen}`;
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él, iría a ${haria}.` };
+        const haria = `ask ${origen} for a device code`;
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` };
     }
     await reintentarPorRevocar(d, d.ahora() + 15_000);
     let c;
@@ -75,7 +76,7 @@ export async function loginStart(d, flags) {
         await d.guardado.guardarPendiente(origen, pendiente);
     }
     catch (e) {
-        return fallo(SALIDA.inesperado, e instanceof FalloDeLaTerminal ? e.error : "no_se_pudo_guardar", `No pude guardar el inicio de sesión en curso: ${motivo(e)}`);
+        return fallo(SALIDA.inesperado, e instanceof FalloDeLaTerminal ? e.error : "no_se_pudo_guardar", `I couldn't save the login in progress: ${motivo(e)}`);
     }
     return {
         codigo: SALIDA.esperandoAUnaPersona,
@@ -83,7 +84,7 @@ export async function loginStart(d, flags) {
             ok: false, esperando: "persona", verification_uri: c.verificationUri,
             verification_uri_complete: c.verificationUriComplete, user_code: c.userCode, expires_in: c.expiresIn,
         },
-        texto: `Abrí ${c.verificationUriComplete} y confirmá el código ${c.userCode}. Después corré \`supcoflow login --wait\`.`,
+        texto: `Open ${c.verificationUriComplete} and confirm the code ${c.userCode}. Then run \`supcoflow login --wait\`.`,
     };
 }
 export async function loginWait(d) {
@@ -96,7 +97,7 @@ export async function loginWait(d) {
     const techo = () => Math.max(0, Math.min(TECHO_DE_UN_PASO_MS, limite - d.ahora()));
     const p = await d.guardado.leerPendiente(origen);
     if (p === null) {
-        return fallo(SALIDA.entradaInvalida, "sin_login_en_curso", "No hay un inicio de sesión en curso: empezá con `supcoflow login --start`.");
+        return fallo(SALIDA.entradaInvalida, "sin_login_en_curso", "There is no login in progress: start with `supcoflow login --start`.");
     }
     // La anterior se lee ANTES de sondear, así no consume la reserva del cierre. Se pide por
     // `leerClaveCompleta` para saber de paso si SUPCOFLOW_TOKEN está definida (sin costo: la variable
@@ -110,9 +111,9 @@ export async function loginWait(d) {
     // y sin borrar el pendiente, así el mismo `--wait` sirve cuando el llavero vuelva.
     if (!lectura.completa) {
         const salida = conVariable
-            ? "desbloqueá el llavero y volvé a llamar `supcoflow login --wait`."
-            : "desbloqueá el llavero y volvé a llamar `supcoflow login --wait` (o, sin login, exportá SUPCOFLOW_TOKEN con una clave vigente).";
-        return fallo(SALIDA.inesperado, "no_pude_leer_la_clave", `No pude leer tu clave guardada (el llavero no respondió), y sin saber cuál es no la puedo reemplazar sin dejarla viva: ${salida}`);
+            ? "unlock the keychain and run `supcoflow login --wait` again."
+            : "unlock the keychain and run `supcoflow login --wait` again (or, without logging in, export SUPCOFLOW_TOKEN with a valid key).";
+        return fallo(SALIDA.inesperado, "no_pude_leer_la_clave", `I couldn't read your saved key (the keychain didn't respond), and without knowing which one it is I can't replace it without leaving it active: ${salida}`);
     }
     const anterior = lectura.valor;
     let fin;
@@ -132,26 +133,26 @@ export async function loginWait(d) {
             return {
                 codigo: SALIDA.esperandoAUnaPersona,
                 json: { ok: false, esperando: "persona", user_code: fin.pendiente.userCode, verification_uri_complete: fin.pendiente.verificationUriComplete },
-                texto: `Todavía no se confirmó. Abrí ${fin.pendiente.verificationUriComplete} y confirmá el código ${fin.pendiente.userCode}; después volvé a correr \`supcoflow login --wait\`.`,
+                texto: `Not confirmed yet. Open ${fin.pendiente.verificationUriComplete} and confirm the code ${fin.pendiente.userCode}; then run \`supcoflow login --wait\` again.`,
             };
         case "token": {
             const r = await reemplazarClave(d, { clave: fin.clave, equipo: fin.equipo }, anterior?.clave ?? null, limite);
             // Va acá y no adentro de `reemplazarClave` porque es acá donde se supo, antes de sondear, sin
             // gastar reserva: preguntarlo al final costaría otra lectura lenta del guardado.
             if (conVariable && r.json.guardada_en !== undefined) {
-                d.avisar("SUPCOFLOW_TOKEN está definida y tiene prioridad sobre la clave que acabo de guardar.");
+                d.avisar("SUPCOFLOW_TOKEN is set and takes priority over the key I just saved.");
             }
             return r;
         }
         case "rechazado":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.haceFaltaUnaPersona, "acceso_rechazado", "Rechazaron el acceso desde la consola; tu sesión anterior, si había, sigue igual.");
+            return fallo(SALIDA.haceFaltaUnaPersona, "acceso_rechazado", "Access was denied in the console; your previous session, if there was one, is unchanged.");
         case "vencido":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.faltaLogin, "codigo_vencido", `El código venció. ${VOLVER_A_EMPEZAR}`);
+            return fallo(SALIDA.faltaLogin, "codigo_vencido", `The code has expired. ${VOLVER_A_EMPEZAR}`);
         case "invalido":
             await d.guardado.borrarPendiente(origen, techo());
-            return fallo(SALIDA.faltaLogin, "codigo_invalido", `El código ya no vale. ${VOLVER_A_EMPEZAR}`);
+            return fallo(SALIDA.faltaLogin, "codigo_invalido", `The code is no longer valid. ${VOLVER_A_EMPEZAR}`);
     }
 }
 // El login de una persona frente a la terminal: los mismos dos pasos, encadenados. Sin TTY (o con
@@ -160,14 +161,14 @@ export async function loginWait(d) {
 const PAUSA_ENTRE_TRAMOS_MS = 1_000;
 export async function loginInteractivo(d, flags) {
     if (!d.esTty || flags.json) {
-        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Sin terminal interactiva usá `supcoflow login --start --json` y después `supcoflow login --wait --json`.");
+        return fallo(SALIDA.entradaInvalida, "hace_falta_tty", "Without an interactive terminal, use `supcoflow login --start --json` and then `supcoflow login --wait --json`.");
     }
     const inicio = await loginStart(d, flags);
     if (inicio.codigo !== SALIDA.esperandoAUnaPersona)
         return inicio;
     // El texto de `--start` le dice a la persona que corra `--wait`; acá eso lo hace el comando solo.
     const { verification_uri_complete: url, user_code: codigo } = inicio.json;
-    d.mostrar(`Abrí ${String(url)} y confirmá el código ${String(codigo)}. Espero acá…`);
+    d.mostrar(`Open ${String(url)} and confirm the code ${String(codigo)}. I'll wait here...`);
     // Cada tramo termina por su cuenta (≤ 90 s) y el código vence a los pocos minutos, así que el
     // bucle tiene fin aunque la persona nunca conteste: termina en `codigo_vencido`.
     let r;
@@ -206,9 +207,9 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
             revocada = false;
         }
         const despues = revocada
-            ? "La revoqué para que no quede viva; tu sesión anterior, si había, sigue como estaba."
-            : "Tampoco pude revocarla: revocala en la consola, en «Accesos desde la terminal».";
-        return fallo(SALIDA.inesperado, "no_se_pudo_guardar", `No pude guardar la clave nueva (${motivo(e)}). ${despues}`);
+            ? "I revoked it so it doesn't stay active; your previous session, if there was one, is as it was."
+            : "I couldn't revoke it either: revoke it in the console, under \"Accesos desde la terminal\" (the console is in Spanish).";
+        return fallo(SALIDA.inesperado, "no_se_pudo_guardar", `I couldn't save the new key (${motivo(e)}). ${despues}`);
     }
     // 2. Revocar la anterior, o anotarla.
     let anteriorRevocada = null;
@@ -228,10 +229,10 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
             try {
                 await d.guardado.anotarPorRevocar(origen, anterior, techo());
                 quedaPorRevocar = true;
-                d.avisar("No pude revocar tu clave anterior; quedó anotada y la reintento en el próximo login o logout.");
+                d.avisar("I couldn't revoke your previous key; it's noted down and I'll try again on the next login or logout.");
             }
             catch {
-                const message = "No pude revocar ni anotar tu clave anterior: revocala en la consola, en «Accesos desde la terminal».";
+                const message = "I couldn't revoke or note down your previous key: revoke it in the console, under \"Accesos desde la terminal\" (the console is in Spanish).";
                 d.avisar(message);
                 if (queda() >= PLAZO_MINIMO_MS)
                     await d.guardado.borrarPendiente(origen, techo());
@@ -245,10 +246,10 @@ export async function reemplazarClave(d, nueva, anterior, limite) {
     // 3. Borrar el pendiente; su `false` no cambia nada.
     if (queda() >= PLAZO_MINIMO_MS)
         await d.guardado.borrarPendiente(origen, techo());
-    const donde = guardadaEn === "llavero" ? "el llavero del sistema" : "el archivo de credenciales";
+    const donde = guardadaEn === "llavero" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
     return {
         codigo: SALIDA.ok,
         json: { ok: true, equipo: nueva.equipo, guardada_en: guardadaEn, anterior_revocada: anteriorRevocada, queda_por_revocar: quedaPorRevocar },
-        texto: `Sesión iniciada en el equipo ${nueva.equipo}; la clave quedó en ${donde}.`,
+        texto: `Logged in to team ${nueva.equipo}; the key is saved in ${donde}.`,
     };
 }

package/dist/comandos/logout.js

@@ -2,6 +2,7 @@
 // (Review Focus 9 y 14). Borrar sin revocar dejaría la clave sirviendo en el motor y sin nadie que
 // la recuerde: por eso, si el motor no confirma, no se borra nada y el comando sale 1.
 import { FalloDeLaTerminal, SALIDA, taparSecretos } from "../contrato.js";
+import { NOMBRE_DE_LA_FUENTE } from "../guardado/index.js";
 import { reintentarPorRevocar } from "./login.js";
 const motivo = (e) => e instanceof FalloDeLaTerminal ? e.message : taparSecretos(e instanceof Error ? e.message : String(e));
 export async function comandoLogout(d, flags) {
@@ -9,7 +10,7 @@ export async function comandoLogout(d, flags) {
     // Sin nada legible y un almacén que no contestó, no se sabe si hay sesión: decir «no había»
     // dejaría creer que no queda ninguna clave viva (Review Focus 12).
     const noPudeLeer = (extra = {}) => {
-        const message = "No pude leer la clave guardada (el llavero no respondió); no cerré nada. Probá de nuevo.";
+        const message = "I couldn't read the saved key (the keychain didn't respond); I didn't log out. Try again.";
         return { codigo: SALIDA.inesperado, json: { ok: false, error: "no_pude_leer_la_clave", message, ...extra }, texto: message };
     };
     if (flags.dryRun) {
@@ -18,20 +19,20 @@ export async function comandoLogout(d, flags) {
         if (vigente === null && !lectura.completa)
             return noPudeLeer({ dry_run: true });
         if (vigente === null) {
-            return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, habia_sesion: false }, texto: "No hay sesión iniciada: no haría nada." };
+            return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, habia_sesion: false }, texto: "You are not logged in: there is nothing to do." };
         }
-        const haria = `revocar la clave de ${vigente.fuente} en ${origen}` + (vigente.fuente !== "env" ? " y borrarla" : "");
-        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `Con --dry-run no hago nada; sin él, iría a ${haria}.` };
+        const haria = `revoke the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]} at ${origen}` + (vigente.fuente !== "env" ? " and delete it" : "");
+        return { codigo: SALIDA.ok, json: { ok: true, dry_run: true, haria }, texto: `With --dry-run I do nothing; without it: ${haria}.` };
     }
     // Lo pendiente de antes va primero: un logout es justo cuando la persona espera que no quede
     // ninguna clave suya viva, y es la última oportunidad que tiene la terminal de revocarlas.
     const { quedan } = await reintentarPorRevocar(d, d.ahora() + 15_000);
     // `null` es «no lo pude comprobar» y se dice así: un 0 haría creer que no queda nada vivo.
     if (quedan === null) {
-        d.avisar("No pude comprobar cuántas claves quedan por revocar; las que haya siguen anotadas y las reintento en el próximo login o logout.");
+        d.avisar("I couldn't check how many keys are left to revoke; any that exist are still noted down and I'll try again on the next login or logout.");
     }
     else if (quedan > 0) {
-        d.avisar(`Quedan ${quedan} clave(s) anterior(es) sin revocar; siguen anotadas y las reintento en el próximo login o logout.`);
+        d.avisar(`${quedan} previous key(s) are still not revoked; they are noted down and I'll try again on the next login or logout.`);
     }
     const lectura = await d.guardado.leerClaveCompleta(origen);
     const vigente = lectura.valor;
@@ -40,22 +41,22 @@ export async function comandoLogout(d, flags) {
     const conPendientes = (json) => ({ ...json, quedan_por_revocar: quedan, ...(lectura.completa ? {} : { lectura_completa: false }) });
     if (vigente === null) {
         await d.guardado.borrarPendiente(origen);
-        return { codigo: SALIDA.ok, json: conPendientes({ ok: true, habia_sesion: false }), texto: "No había sesión iniciada." };
+        return { codigo: SALIDA.ok, json: conPendientes({ ok: true, habia_sesion: false }), texto: "You were not logged in." };
     }
     let revocada;
     try {
         revocada = (await d.revocarPropia(d.api, vigente.clave)) === "revocada";
     }
     catch (e) {
-        const cual = vigente.fuente === "env" ? "la clave de SUPCOFLOW_TOKEN sigue viva" : "la clave sigue guardada";
-        const message = `No pude revocar la clave, así que no cerré la sesión (${motivo(e)}); ${cual}. Probá de nuevo.`;
+        const cual = vigente.fuente === "env" ? "the key in SUPCOFLOW_TOKEN is still active" : "the key is still saved";
+        const message = `I couldn't revoke the key, so I didn't log out (${motivo(e)}); ${cual}. Try again.`;
         const error = e instanceof FalloDeLaTerminal ? e.error : "inesperado";
         return { codigo: SALIDA.inesperado, json: conPendientes({ ok: false, error, message }), texto: message };
     }
     // La variable no es nuestra: se revoca la clave que trae, pero lo guardado es OTRA credencial,
     // que sólo se cierra revocándola a ella. Borrarla acá la dejaría viva y olvidada.
     if (vigente.fuente === "env") {
-        d.avisar("Revoqué la clave de SUPCOFLOW_TOKEN; sacala de tu entorno.");
+        d.avisar("I revoked the key in SUPCOFLOW_TOKEN; remove it from your environment.");
         // `undefined` = no se pudo leer: no se afirma que no haya, el json lleva `null` en vez de mentir.
         let guardada;
         try {
@@ -66,19 +67,19 @@ export async function comandoLogout(d, flags) {
             guardada = undefined;
         }
         if (guardada) {
-            d.avisar(`Sigue guardada otra clave en ${guardada.fuente}; para cerrarla, corré \`supcoflow logout\` sin SUPCOFLOW_TOKEN.`);
+            d.avisar(`Another key is still saved in ${NOMBRE_DE_LA_FUENTE[guardada.fuente]}; to log it out, run \`supcoflow logout\` without SUPCOFLOW_TOKEN.`);
         }
         return {
             codigo: SALIDA.ok,
             json: conPendientes({ ok: true, revocada, fuente: "env", queda_clave_guardada: guardada === undefined ? null : guardada !== null }),
-            texto: "Revoqué la clave de SUPCOFLOW_TOKEN.",
+            texto: "I revoked the key in SUPCOFLOW_TOKEN.",
         };
     }
     // Con la lectura incompleta se borra sólo la copia que se leyó y se acaba de revocar: la del
     // almacén que no contestó puede ser otra clave, viva, y borrarla sin revocarla la olvidaría.
     if (!lectura.completa) {
-        const otro = vigente.fuente === "archivo" ? "el llavero del sistema" : "el archivo de credenciales";
-        d.avisar(`Cierro la clave de ${vigente.fuente}, pero no pude leer ${otro}: puede quedar otra copia guardada ahí; cuando responda, volvé a correr \`supcoflow logout\`.`);
+        const otro = vigente.fuente === "archivo" ? NOMBRE_DE_LA_FUENTE.llavero : NOMBRE_DE_LA_FUENTE.archivo;
+        d.avisar(`I'm logging out the key in ${NOMBRE_DE_LA_FUENTE[vigente.fuente]}, but I couldn't read ${otro}: another copy may still be saved there; when it responds, run \`supcoflow logout\` again.`);
     }
     try {
         if (lectura.completa)
@@ -88,9 +89,9 @@ export async function comandoLogout(d, flags) {
     }
     catch (e) {
         // La clave ya no sirve en el motor, pero quedó escrita: el comando no puede decir que terminó bien.
-        const message = `La clave quedó revocada pero no pude borrarla: ${motivo(e)}`;
+        const message = `The key was revoked but I couldn't delete it: ${motivo(e)}`;
         return { codigo: SALIDA.inesperado, json: conPendientes({ ok: false, error: "no_se_pudo_borrar", message }), texto: message };
     }
     await d.guardado.borrarPendiente(origen);
-    return { codigo: SALIDA.ok, json: conPendientes({ ok: true, revocada }), texto: "Sesión cerrada." };
+    return { codigo: SALIDA.ok, json: conPendientes({ ok: true, revocada }), texto: "Logged out." };
 }