supcoflow 0.0.0-stage → 0.3.0

package/dist/secreto-a-archivo.js

@@ -0,0 +1,109 @@
+// El secreto de una clave de consulta, a un archivo que nombró la persona (§6.5, decisión 5 del bloque 4).
+// Nunca sale por stdout: quien corre `claves crear` suele ser un asistente, y lo que lee queda en su
+// contexto. El archivo es la ÚNICA copia, así que se escribe con las mismas defensas que las credenciales:
+// fuera de un repo de git (un `git add -A` la publicaría), `0600`, sin atravesar enlaces y vía `.tmp` +
+// `rename` (nunca queda un archivo a medio escribir).
+//
+// Lo que ya hay en el destino no se pisa salvo que sea una clave de LA MISMA fila (mismo sufijo): eso es
+// la recuperación de un intento a medias, y `claves crear` sólo llega con el candado tomado. Cualquier otra
+// cosa podría ser una clave vigente de otro proyecto. Y nada de lo que hay ahí llega a un mensaje.
+//
+// ─── Un destino ausente se publica sin pisar (revisión del 2026-10-16) ──────────
+//
+// El candado es por proyecto + NOMBRE de la clave, no por destino. Dos `claves crear` con nombres distintos y
+// el mismo `--guardar-en` leían los dos «ausente» y hacían los dos `rename`: el segundo pisaba el archivo del
+// primero, que igual confirmaba su clave, activa y sin nadie que tuviera el secreto. Por eso, cuando el
+// destino estaba ausente, el temporal se publica con una operación que FALLA si ya existe (`link`); quien
+// llega segundo recibe el mismo 4 de «ya tiene otra cosa» y no confirma. El `rename` que pisa queda sólo
+// para la recuperación de la MISMA fila, que sí está bajo el candado de ese nombre.
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+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 };
+export function crearGuardaDeSecretos(fs) {
+    function borrarTemporal(tmp) {
+        try {
+            fs.borrarSiExiste(tmp);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    function leer(ruta) {
+        const l = fs.leerSinSeguir(ruta, TOPE);
+        if (l.tipo === "ausente")
+            return { estado: "ausente" };
+        if (l.tipo !== "contenido")
+            return { estado: "otra_cosa" };
+        // Un salto final (el que escribe `guardar`, o el de un editor) se tolera; cualquier otra cosa no.
+        const m = CLAVE.exec(l.texto.endsWith("\n") ? l.texto.slice(0, -1) : l.texto);
+        return m ? { estado: "clave", claveId: `cla_${m[1]}`, secreto: m[0] } : { estado: "otra_cosa" };
+    }
+    function validarDestino(ruta) {
+        const destino = path.resolve(ruta);
+        // `realpath` lanza con un tramo que es un enlace roto: sin saber dónde cae, no se escribe.
+        let raiz;
+        try {
+            raiz = dentroDeUnWorkingTree(path.dirname(destino), fs);
+        }
+        catch {
+            return { error: "no pude resolver la ruta real de la carpeta (¿un enlace roto?)", 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 null;
+    }
+    return {
+        leer,
+        validarDestino,
+        guardar(ruta, claveId, secreto) {
+            const destino = path.resolve(ruta);
+            // También acá, aunque `claves crear` ya lo miró antes de pedir: entre una cosa y otra pasa tiempo.
+            const invalido = validarDestino(destino);
+            if (invalido !== null)
+                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 };
+            if (hay.tipo !== "ausente") {
+                const actual = leer(destino);
+                if (actual.estado !== "clave" || actual.claveId !== claveId)
+                    return OCUPADO;
+            }
+            // El temporal en la MISMA carpeta (el `rename` sólo es atómico dentro del mismo disco), con nombre al
+            // azar y en exclusiva: `wx` no atraviesa un enlace que alguien dejara con ese nombre.
+            const tmp = path.join(path.dirname(destino), `.${path.basename(destino)}.${randomUUID()}.tmp`);
+            let publicado;
+            try {
+                fs.escribirExclusivo(tmp, secreto + "\n", 0o600);
+                if (hay.tipo === "ausente") {
+                    publicado = fs.publicarSinPisar(tmp, destino);
+                }
+                else {
+                    fs.renombrar(tmp, destino);
+                    publicado = "publicado";
+                }
+            }
+            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 };
+            }
+            // 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
+            // guardada sin confirmar.
+            borrarTemporal(tmp);
+            // Otro apareció entre la lectura y la publicación: lo suyo queda intacto y esta clave no se confirma.
+            if (publicado === "existe")
+                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 "guardado";
+        },
+    };
+}

package/dist/sondeo.js

@@ -0,0 +1,47 @@
+import { TECHO_DEL_LLAVERO_MS } from "./guardado/llavero.js";
+// 90 s para el comando ENTERO, guardado y revocación incluidos, no sólo para los sondeos: quien
+// llama suele ser un asistente cuya herramienta de terminal corta a los 2 min (Claude Code), y un
+// comando cortado a mitad de cierre puede dejar la clave nueva sin guardar o la vieja sin revocar.
+// Por la misma razón (P13 del motor) nada espera en silencio más que eso: se parte en tramos.
+export const TRAMO_MAXIMO_MS = 90_000;
+// Lo que se aparta del tramo para cerrar después de recibir el token. La secuencia de cierre tiene a
+// lo sumo cuatro operaciones lentas, cada una con techo de 5 s: guardar la nueva (el llavero; si
+// vence, el archivo es local e inmediato), revocar la anterior en el motor, anotarla «por revocar»
+// si no se pudo, y borrar el pendiente. 4 × 5 s + 2 s de margen = 22 s. La clave anterior se lee
+// ANTES de sondear (no consume reserva), y el pendiente sólo se persiste tras respuestas no finales.
+export const RESERVA_PARA_CERRAR_MS = 22_000;
+// Una operación de cierre opcional (revocar la anterior, borrar el pendiente) con menos que esto
+// no se intenta: con medio segundo no contesta ni un motor sano, y lo que no se hace queda anotado.
+export const PLAZO_MINIMO_MS = 500;
+// Un sondeo con menos plazo que esto casi seguro vence sin respuesta: mejor salir 5 y que el
+// próximo `--wait` sondee con un tramo entero.
+export const PLAZO_MINIMO_DE_SONDEO_MS = 2_000;
+const PLAZO_MAXIMO_DE_CANJE_MS = 15_000;
+export async function sondearUnTramo(inicial, d) {
+    let p = inicial;
+    for (;;) {
+        // El intervalo se cuenta desde el último sondeo GUARDADO, no desde que arrancó este comando
+        // (Review Focus 4): un `--wait` enseguida de otro espera lo que falta, en vez de ganarse un
+        // `slow_down` del motor.
+        const ahora = d.ahora();
+        const proximo = p.ultimoSondeoEn === null ? ahora : Math.max(ahora, p.ultimoSondeoEn + p.intervaloS * 1000);
+        if (proximo >= p.venceEn)
+            return { tipo: "vencido" };
+        if (d.finDeSondeos - proximo < PLAZO_MINIMO_DE_SONDEO_MS)
+            return { tipo: "sigue", pendiente: p };
+        if (proximo > ahora)
+            await d.dormir(proximo - ahora);
+        const c = await d.canjear(p.deviceCode, Math.min(PLAZO_MAXIMO_DE_CANJE_MS, d.finDeSondeos - d.ahora()));
+        // El token es la ÚNICA copia de la clave (el motor no la reentrega): no espera a ninguna
+        // escritura del pendiente, que podría colgarse o lanzar y perderla (Review Focus 13).
+        if (c.tipo === "token")
+            return { tipo: "token", clave: c.clave, equipo: c.equipo };
+        if (c.tipo !== "pendiente" && c.tipo !== "slow_down")
+            return { tipo: c.tipo };
+        // El último sondeo se fecha con la RESPUESTA: el motor lo vio a más tardar entonces, así que
+        // contar desde ahí nunca adelanta el próximo. Y se guarda ANTES de seguir (Review Focus 11):
+        // si la red se cae en el sondeo siguiente, el intervalo nuevo de un `slow_down` ya quedó escrito.
+        p = { ...p, ultimoSondeoEn: d.ahora(), intervaloS: p.intervaloS + (c.tipo === "slow_down" ? 5 : 0) };
+        await d.persistir(p, Math.min(TECHO_DEL_LLAVERO_MS, Math.max(PLAZO_MINIMO_MS, d.finDeSondeos - d.ahora())));
+    }
+}

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "supcoflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.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" },
+  "files": ["dist"],
+  "engines": { "node": ">=24" },
+  "scripts": { "build": "tsc -p tsconfig.json && chmod +x dist/cli.js", "test": "vitest run", "typecheck": "tsc --noEmit" },
+  "dependencies": {},
+  "devDependencies": { "@types/node": "^24.0.0", "typescript": "^5.9.0", "vitest": "^4.0.0" },
+  "license": "UNLICENSED"
+}