supcoflow 0.0.0-stage → 0.3.0

package/dist/cli.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+// El binario `supcoflow`: lee los argumentos, arma el entorno real y despacha. Todo va dentro de un
+// solo try/catch: cualquier cosa que se escape (un archivo de credenciales ilegible, un llavero roto)
+// sale como un 1 limpio, en una línea si se pidió --json, sin traza y con los secretos tapados.
+import { revocarPropia } from "./api.js";
+import { leerArgumentos } from "./argumentos.js";
+import { clavesCrear, clavesListar, clavesRevocar } from "./comandos/claves.js";
+import { chatLogo, chatMarca, chatPrenderApagar, comandoConfiguracion, sitios } from "./comandos/configurar.js";
+import { comandoCatalogo, datosFijar, politicaFijar } from "./comandos/datos-y-politica.js";
+import { ayuda, comandoDescribir, DESCRIPCION } from "./comandos/describir.js";
+import { loginInteractivo, loginStart, loginWait } from "./comandos/login.js";
+import { comandoLogout } from "./comandos/logout.js";
+import { proyectoCrear, proyectoVer } from "./comandos/proyecto.js";
+import { comandoQuienSoy } from "./comandos/quien-soy.js";
+import { repoConectarInteractivo, repoConectarStart, repoConectarWait } from "./comandos/repo-conectar.js";
+import { emitir, FalloDeLaTerminal, resultadoDeFallo, SALIDA } from "./contrato.js";
+import { entornoReal } from "./entorno.js";
+import { flagQueNoAplica } from "./flags-por-comando.js";
+const COMANDOS = new Set(DESCRIPCION.comandos.map((c) => c.nombre));
+const invalida = (error, message) => new FalloDeLaTerminal(SALIDA.entradaInvalida, error, message);
+async function correr(argv) {
+    // Si los argumentos no se pueden leer no se sabe qué flags hay: se mira `--json` a mano para que
+    // el error salga en el formato que pidió quien llama.
+    let json = argv.includes("--json");
+    try {
+        const { comando, flags } = leerArgumentos(argv);
+        json = flags.json;
+        if (comando !== null && !COMANDOS.has(comando)) {
+            throw invalida("comando_desconocido", `No conozco el comando «${comando}». Probá \`supcoflow --help\`.`);
+        }
+        if (flags.help || comando === null) {
+            const texto = ayuda(comando);
+            return { r: { codigo: SALIDA.ok, json: { ok: true, ayuda: texto }, texto }, json };
+        }
+        const presentes = {
+            start: flags.start, wait: flags.wait, repo: flags.repo !== null, install: flags.install !== null, test: flags.test !== null,
+            sitio: flags.sitio !== null, titulo: flags.titulo !== null, saludo: flags.saludo !== null, tema: flags.tema.length > 0,
+            archivo: flags.archivo !== null, permitir: flags.permitir !== null, modo: flags.modo !== null,
+            nombre: flags.nombre !== null, guardarEn: flags.guardarEn !== null, id: flags.id !== null,
+        };
+        const noAplica = flagQueNoAplica(comando, Object.keys(presentes).filter((k) => presentes[k]));
+        if (noAplica !== null)
+            throw invalida("flag_no_aplica", noAplica);
+        if (flags.start && flags.wait) {
+            throw invalida("flags_incompatibles", "--start y --wait van por separado: primero uno y después el otro.");
+        }
+        if (comando === "describir")
+            return { r: comandoDescribir(), json };
+        if (comando === "login") {
+            // ANTES de armar el entorno: no hay cómo simular un canje sin consumirlo, y este error no
+            // puede depender de leer nada guardado ni de llamar al motor.
+            if (flags.wait && flags.dryRun) {
+                throw invalida("dry_run_no_soportado", "`login --wait` no tiene --dry-run: sondear consume el código. Probá `supcoflow login --start --dry-run`.");
+            }
+        }
+        const e = entornoReal();
+        switch (comando) {
+            case "login":
+                if (flags.start)
+                    return { r: await loginStart(e.login, flags), json };
+                if (flags.wait)
+                    return { r: await loginWait(e.login), json };
+                // Sin TTY, `login --dry-run` igual tiene algo que decir: lo que haría el primer paso.
+                if (flags.dryRun)
+                    return { r: await loginStart(e.login, { dryRun: true }), json };
+                return { r: await loginInteractivo({ ...e.login, esTty: e.esTty, mostrar: e.mostrar }, flags), json };
+            case "logout":
+                return {
+                    r: await comandoLogout({
+                        api: e.api, guardado: e.guardado, ahora: e.login.ahora, avisar: e.avisar,
+                        revocarPropia: (a, clave, plazoMs) => revocarPropia(a, clave, fetch, plazoMs),
+                    }, flags),
+                    json,
+                };
+            case "quien-soy":
+                return { r: await comandoQuienSoy({ api: e.api, guardado: e.guardado, quienSoy: e.quienSoy, avisar: e.avisar }), json };
+            case "repo conectar":
+                if (flags.start)
+                    return { r: await repoConectarStart(e.conexion, flags), json };
+                // `--wait` sólo lee (un GET por tramo): con --dry-run haría lo mismo, así que no se rechaza.
+                if (flags.wait)
+                    return { r: await repoConectarWait(e.conexion, flags), json };
+                // Como `login`: sin TTY, --dry-run igual dice lo que haría el primer paso, sin tocar el motor.
+                if (flags.dryRun)
+                    return { r: await repoConectarStart(e.conexion, { repo: flags.repo, dryRun: true }), json };
+                return { r: await repoConectarInteractivo({ ...e.conexion, esTty: e.esTty, mostrar: e.mostrar }, flags), json };
+            case "proyecto crear":
+                return { r: await proyectoCrear(e.proyecto, flags), json };
+            case "proyecto ver":
+                return { r: await proyectoVer(e.proyecto, flags), json };
+            case "catalogo":
+                return { r: await comandoCatalogo(e.configurar), json };
+            case "configuracion":
+                return { r: await comandoConfiguracion(e.configurar, flags), json };
+            case "chat prender":
+                return { r: await chatPrenderApagar(e.configurar, flags, true), json };
+            case "chat apagar":
+                return { r: await chatPrenderApagar(e.configurar, flags, false), json };
+            case "chat marca":
+                return { r: await chatMarca(e.configurar, flags), json };
+            case "chat logo":
+                return { r: await chatLogo(e.configurar, flags), json };
+            case "sitios agregar":
+                return { r: await sitios(e.configurar, flags, "agregar"), json };
+            case "sitios quitar":
+                return { r: await sitios(e.configurar, flags, "quitar"), json };
+            case "datos fijar":
+                return { r: await datosFijar(e.configurar, flags), json };
+            case "politica fijar":
+                return { r: await politicaFijar(e.configurar, flags), json };
+            case "claves crear":
+                return { r: await clavesCrear(e.claves, flags), json };
+            case "claves listar":
+                return { r: await clavesListar(e.claves, flags), json };
+            case "claves revocar":
+                return { r: await clavesRevocar(e.claves, flags), json };
+        }
+        throw new Error(`comando sin despacho: ${comando}`);
+    }
+    catch (e) {
+        return { r: resultadoDeFallo(e), json };
+    }
+}
+// `process.exitCode` y nunca `process.exit()`: éste corta el proceso con stdout a medio escribir
+// cuando la salida va a un pipe, y quien llama leería una línea de JSON partida.
+const { r, json } = await correr(process.argv.slice(2));
+emitir(r, json, (s) => void process.stdout.write(s));
+process.exitCode = r.codigo;

package/dist/comandos/clave-vigente.js

@@ -0,0 +1,18 @@
+// La clave con la que la terminal le habla al motor, leída igual para todo comando que la necesite
+// (`quien-soy`, `repo conectar`, …): un solo lugar decide qué es «sin sesión» y qué es «no pude mirar».
+import { SALIDA } from "../contrato.js";
+export async function claveVigente(guardado, origen) {
+    const lectura = await guardado.leerClaveCompleta(origen);
+    const vigente = lectura.valor;
+    // «Iniciá sesión» con la clave guardada en un llavero que no contestó invita a un login que la
+    // pisaría: no es «sin sesión», es «no pude mirar» (Review Focus 12).
+    if (vigente === null && !lectura.completa) {
+        const message = "No pude leer la clave guardada (el llavero no respondió). Desbloquealo y probá de nuevo.";
+        return { ok: false, resultado: { codigo: SALIDA.inesperado, json: { ok: false, error: "llavero_no_responde", message }, texto: message } };
+    }
+    if (vigente === null) {
+        const message = "Iniciá sesión con `supcoflow login`.";
+        return { ok: false, resultado: { codigo: SALIDA.faltaLogin, json: { ok: false, error: "sin_sesion", message }, texto: message } };
+    }
+    return { ok: true, vigente: { clave: vigente.clave, fuente: vigente.fuente, completa: lectura.completa } };
+}

package/dist/comandos/claves.js

@@ -0,0 +1,161 @@
+// `supcoflow claves crear`: una clave de consulta (sólo lee su proyecto) para CI. Dos fases (§6.5): el
+// motor la crea pendiente y devuelve el secreto UNA vez; la terminal lo guarda en el archivo que dijo la
+// persona y recién ahí confirma mandándolo de vuelta (demuestra que lo tiene). El secreto nunca sale por
+// stdout ni stderr: quien llama suele ser un asistente, y su salida queda en su contexto.
+//
+// La semántica entera (candado, mirar el destino antes, el ciclo) está en la tarea C4 del plan del bloque 4
+// y en los comentarios de abajo; cada rama de este archivo es una de esas reglas.
+import path from "node:path";
+import { resultadoDeFallo, SALIDA } from "../contrato.js";
+import { desenlace, dryRun, fallo, rutaDe } from "./configurar.js";
+import { proyectoDelRepo } from "./proyecto-del-repo.js";
+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`.");
+    // 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 p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    const ruta = rutaDe(p.proyecto, "/claves");
+    // Antes de pedir nada: un destino que no sirve (dentro de un repo) dejaba una fila pendiente de más.
+    const invalido = d.secretos.validarDestino(destino);
+    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}`;
+    // 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
+    // autentica y después escribirlo no es atómico: sin candado, un segundo `claves crear` atrasado pisaba
+    // el secreto vigente con uno que después no confirmaba (segunda revisión externa, hallazgo 1). Dos
+    // 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.");
+    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.`);
+    }
+    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.`);
+    }
+    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}.` };
+        };
+        // 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
+        // de idempotencia ya se olvidó). Una que no autentica sólo se retoma si hay un intento a medias
+        // nuestro. Cualquier otra cosa (una clave personal aunque autentique, una de otro proyecto, una
+        // revocada) no se pisa: podría ser una clave vigente de alguien (tercera revisión, hallazgo 2).
+        const hay = d.secretos.leer(destino);
+        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.`);
+        }
+        // 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 });
+            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);
+                const ahora = d.secretos.leer(destino);
+                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.`);
+            }
+            if (r.status !== 201) {
+                if (r.cuerpo.error === "clave_vencida") {
+                    // La fila vencida no vuelve: el próximo intento tiene que ser otra clave de idempotencia.
+                    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.`);
+                }
+                // Misma clave de reintento con otro cuerpo: no se arregla reintentando, y guardada trabaría para siempre.
+                if (r.cuerpo.error === "idempotency_key_reusada")
+                    await d.idempotencia.olvidar(OPERACION, alcance);
+                return desenlace(r, () => { throw new Error("inalcanzable"); });
+            }
+            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.");
+            // 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é.");
+            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.`);
+            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}.` };
+            }
+            // 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.");
+    }
+    catch (e) {
+        // Red caída a mitad, o el registro estricto que no pudo guardar: la clave de idempotencia (si llegó a
+        // guardarse) se conserva y el reintento retoma la misma fila.
+        return resultadoDeFallo(e);
+    }
+    finally {
+        candado.soltar();
+    }
+}
+export async function clavesListar(d, flags) {
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    try {
+        // 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(", ")}.`;
+        return { codigo: SALIDA.ok, json: { ok: true, claves }, texto };
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+}
+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`).");
+    }
+    const claveId = flags.id;
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    const ruta = rutaDe(p.proyecto, "/claves/revocar");
+    if (flags.dryRun)
+        return dryRun(`POST ${ruta} {clave_id: ${claveId}}`);
+    try {
+        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 desenlace(r, () => ({ codigo: SALIDA.ok, json: { ok: true, clave_id: claveId }, texto: `Revoqué la clave ${claveId}; deja de autenticar.` }));
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+}

package/dist/comandos/configurar.js

@@ -0,0 +1,187 @@
+// src/comandos/configurar.ts
+// Los comandos que configuran el proyecto del repo (spec de supcoflow go §5.4, §9). Cada uno resuelve el
+// proyecto, manda UN pedido y traduce la respuesta a los códigos de §13. Lo que se valida acá (un --tema
+// sin `=`, un --sitio que falta) se valida para no gastar un pedido; la regla de verdad es la del motor.
+import path from "node:path";
+import { resultadoDeFallo, SALIDA, taparSecretos } from "../contrato.js";
+import { proyectoDelRepo } from "./proyecto-del-repo.js";
+export const fallo = (codigo, error, message) => ({ codigo, json: { ok: false, error, message }, texto: message });
+const PIDEN_UNA_PERSONA = new Set(["skill_no_aprobada"]);
+const TRANSITORIOS = new Set(["sitios_cambiaron", "idempotency_en_curso"]);
+export function desenlace(r, ok) {
+    if (r.status >= 200 && r.status < 300)
+        return ok(r.cuerpo);
+    // 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.");
+    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.`);
+    }
+    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}).`);
+    if (PIDEN_UNA_PERSONA.has(error))
+        return fallo(SALIDA.haceFaltaUnaPersona, error, message);
+    if (TRANSITORIOS.has(error))
+        return fallo(SALIDA.inesperado, error, message);
+    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 async function comandoConfiguracion(d, flags) {
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    try {
+        const c = await d.leerConfiguracion(d.api, p.clave, p.proyecto.id);
+        const chat = c.chat;
+        const sitiosLista = c.sitios;
+        // El acuerdo de datos frena lo que se guarda y lo que lee la IA que releva el repo; NO alcanza a lo
+        // que ve la IA del propio chat mientras conversa (decisión 1b). Por eso el texto lo dice, y nunca
+        // 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)"
+            : 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.";
+        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)}`,
+            ].join("\n"),
+        };
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+}
+// La política dicha en palabras llanas (decisión del dueño, 2026-10-16): «guardar» frena sólo lo automático
+// del chat; una persona todavía puede pedir el relevamiento desde la consola, y eso gasta. Un motor viejo que
+// no la manda no se adivina: se dice que no vino.
+function textoDePolitica(v) {
+    const modo = v?.modo;
+    if (modo === "relevar")
+        return "relevar: cada problema se releva y nace el issue (gasta).";
+    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ó.";
+}
+// 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
+// de control (C0, DEL y C1); el JSON los conserva, porque ahí van escapados.
+const limpio = (t) => t.replace(/[\u0000-\u001f\u007f-\u009f]/g, "");
+// `marca` es null (nunca se fijó: el chat usa la de fábrica) o {titulo, saludo, tema, logo_url}. Del tema se
+// 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ó.";
+    if (v === null)
+        return "sin fijar (el chat usa la de fábrica).";
+    const m = v;
+    const partes = [];
+    if (typeof m.titulo === "string" && m.titulo !== "")
+        partes.push(`título «${limpio(m.titulo)}»`);
+    if (typeof m.saludo === "string" && m.saludo !== "")
+        partes.push(`saludo «${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(typeof m.logo_url === "string" && m.logo_url !== "" ? "con logo" : "sin logo");
+    return partes.join(", ") + ".";
+}
+export async function chatPrenderApagar(d, flags, habilitar) {
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    const ruta = rutaDe(p.proyecto, "/chat");
+    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.",
+    }));
+}
+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\`.`);
+    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"}.`,
+    }));
+}
+export async function chatMarca(d, flags) {
+    const tema = {};
+    for (const t of flags.tema) {
+        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}».`);
+        const clave = t.slice(0, i);
+        if (clave in tema)
+            return fallo(SALIDA.entradaInvalida, "tema_invalido", `--tema ${clave} va una sola vez.`);
+        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.");
+    }
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    // ─── Se manda la marca ENTERA, mezclada con la guardada (revisión externa del 2026-10-16, hallazgo 5) ───
+    // La route REEMPLAZA la marca (`escribirMarcaDelChat`: lo omitido queda NULL y el tema `{}`), porque así
+    // la usa el formulario de la consola, que manda todo junto y vacía un campo dejándolo en blanco. Mandar
+    // sólo `--titulo` borraba el saludo y los colores. La terminal lee lo guardado y cambia sólo lo nombrado.
+    // Costo aceptado: dos ediciones a la vez (terminal y consola) pueden pisarse; es una persona configurando.
+    // Borrar un campo desde la terminal no existe en este bloque: se hace en la consola.
+    let actual;
+    try {
+        actual = (await d.leerConfiguracion(d.api, p.clave, p.proyecto.id)).marca;
+    }
+    catch (e) {
+        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);
+    if (titulo !== null)
+        cuerpo.titulo = titulo;
+    if (saludo !== null)
+        cuerpo.saludo = saludo;
+    const temaActual = typeof actual?.tema === "object" && actual.tema !== null ? actual.tema : {};
+    const temaFinal = { ...temaActual, ...tema };
+    if (Object.keys(temaFinal).length > 0)
+        cuerpo.tema = temaFinal;
+    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." }));
+}
+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 (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);
+    if ("error" in leido)
+        return fallo(SALIDA.entradaInvalida, "logo_ilegible", `No leo ${flags.archivo}: ${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." }));
+}

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

@@ -0,0 +1,112 @@
+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 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.
+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}.` });
+export function leerPermitir(crudo) {
+    const partes = crudo.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    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")
+        return p;
+    if (partes.length === 0 || partes.includes("nada"))
+        return { error: "`nada` va solo; si no, nombrá lo que sí pasa." };
+    const vistos = new Set();
+    for (const x of partes) {
+        if (vistos.has(x))
+            return { error: `«${x}» está repetido.` };
+        vistos.add(x);
+        if (x.startsWith("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();
+            if (nombre.length === 0)
+                return { error: "`atributo:` va con el nombre exacto del atributo, por ejemplo atributo:plan." };
+            if (nombre.length > MAX_LARGO_DE_ATRIBUTO)
+                return { error: `El nombre de un atributo tiene hasta ${MAX_LARGO_DE_ATRIBUTO} caracteres.` };
+            if (p.atributos.length >= MAX_ATRIBUTOS)
+                return { error: `Hasta ${MAX_ATRIBUTOS} atributos.` };
+            p.atributos.push(nombre);
+        }
+        else if (BANDERAS.includes(x)) {
+            p[x] = true;
+        }
+        else {
+            return { error: `No conozco «${x}». Valen: ${BANDERAS.join(", ")}, atributo:<nombre>, o nada.` };
+        }
+    }
+    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`).");
+    }
+    const permitido = leerPermitir(flags.permitir);
+    if ("error" in permitido)
+        return fallo(SALIDA.entradaInvalida, "permitir_invalido", permitido.error);
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    const ruta = rutaDe(p.proyecto, "/acuerdo-de-datos");
+    if (flags.dryRun)
+        return dryRun(`POST ${ruta} {permitido}`);
+    let r;
+    try {
+        r = await d.configurar(d.api, p.clave, ruta, { permitido });
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    // El acuerdo frena lo que se guarda y lo que lee la IA que releva; NO alcanza a lo que ve la IA del
+    // propio chat mientras conversa (decisión 1b): el texto lo dice y no promete «toda» ni «ninguna» IA.
+    return desenlace(r, (c) => {
+        const version = c.acuerdo?.version;
+        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.`,
+        };
+    });
+}
+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`.");
+    }
+    const modo = flags.modo;
+    const p = await proyectoDelRepo(d, flags);
+    if (!p.ok)
+        return p.resultado;
+    const ruta = rutaDe(p.proyecto, "/politica");
+    if (flags.dryRun)
+        return dryRun(`POST ${ruta} {modo: ${modo}}`);
+    let r;
+    try {
+        r = await d.configurar(d.api, p.clave, ruta, { modo });
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+    return desenlace(r, (c) => ({
+        codigo: SALIDA.ok,
+        json: { ok: true, politica: c.politica },
+        texto: `Política de problemas fijada: ${modo}.`,
+    }));
+}
+export async function comandoCatalogo(d) {
+    const leida = await claveVigente(d.guardado, d.api.origin);
+    if (!leida.ok)
+        return leida.resultado;
+    try {
+        const c = await d.leerCatalogo(d.api, leida.vigente.clave);
+        const items = c.supcoflow.map((i) => `${i.clave}: ${i.valores}`);
+        return { codigo: SALIDA.ok, json: { ok: true, ...c }, texto: items.join("\n") };
+    }
+    catch (e) {
+        return resultadoDeFallo(e);
+    }
+}