@ajuarezso/lienzo-mcp 0.4.0 → 0.5.0

package/lib/instalacion.mjs

@@ -0,0 +1,322 @@
+// Id automático por instalación (21-10-2026, pedido del dueño: «quiero instalarlo y listo; si el id es el problema,
+// asígnale uno»). Detalle en docs/spec.md «Varios agentes por cuenta».
+//
+// Sin LIENZO_AGENTE, cada instalación del puente es un agente con nombre propio `{uid}_agente_{slug}`, con un slug corto
+// (6 caracteres base36) que sale de la máquina y de la instalación (hash del id de la máquina + la clave), así que borrar
+// ~/.lienzo (o un LIENZO_HOME que no dura) en la misma máquina devuelve el MISMO agente y no gasta otro lugar del tope.
+// Se guarda en <LIENZO_HOME>/agente.json; si la máquina no da un id, el slug es aleatorio (y lo sostiene agente.json).
+// Dos perfiles de Claude en la misma Mac comparten ~/.lienzo: la instalación se distingue por el cliente (Claude
+// Code, Claude Desktop…) y su carpeta de configuración (CLAUDE_CONFIG_DIR), así que cada perfil tiene su slug.
+//
+// Retrocompatibilidad: quien ya usaba el puente (0.3.x o antes) era `{uid}_agente`. Si cuando se crea agente.json ya
+// había una sesión en ese LIENZO_HOME (`legadoDisponible`), la PRIMERA instalación que se une a una sala hereda el
+// agente de siempre y lo sigue usando en todas las salas: lo que le pidieron a `{uid}_agente` le sigue llegando. Las
+// demás instalaciones de ese home reciben su slug. Un home nuevo (sin sesión al crear agente.json) no hereda nada.
+//
+// agente.json = {
+//   version: 1,
+//   legadoDisponible: boolean,          // ¿había sesion.json cuando se creó este archivo? Se fija UNA vez
+//   legado: string | null,              // la clave de la instalación que heredó `{uid}_agente`
+//   instalaciones: { [clave]: { agente: string | null, desde: ISO } },  // agente null = el de siempre
+//   nombres: { [clave]: string[] }      // los LIENZO_NOMBRE que ya se aplicaron (ver nombreDeConfigManda)
+// }
+// Escrituras atómicas (temporal + rename) bajo un candado de archivo, como sesion.json.
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, openSync, closeSync, unlinkSync, statSync, rmSync } from 'node:fs';
+import { homedir, platform } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { basename, join, resolve } from 'node:path';
+import { randomBytes, createHash } from 'node:crypto';
+import { RE_SLUG } from './agentes.mjs';
+
+export const ARCHIVO = 'agente.json';
+// Lo que se decidió sobre el agente de siempre, aparte: si se borra SOLO agente.json (con sesion.json todavía ahí), la
+// herencia no se vuelve a repartir y el heredero la recupera (revisión adversarial, 21-10-2026).
+export const ARCHIVO_LEGADO = 'agente.legado.json';
+const CANDADO_VIEJO_MS = 30 * 1000;
+const CANDADO_ESPERA_MS = 10 * 1000;
+const LARGO_SLUG = 6;
+const esperar = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** 6 caracteres base36 al azar (~31 bits): «k3x9q2». Siempre cumple RE_SLUG. */
+export function nuevoSlug(n = LARGO_SLUG) {
+  const b = randomBytes(n);
+  let s = '';
+  for (let i = 0; i < n; i++) s += (b[i] % 36).toString(36);
+  return s;
+}
+
+/** Slug estable derivado de la clave (si agente.json no se puede escribir, la instalación igual tiene su id). */
+export function slugDeRespaldo(home, clave) {
+  const h = createHash('sha256').update(`${home}\0${clave}`).digest();
+  let s = '';
+  for (let i = 0; i < LARGO_SLUG; i++) s += (h[i] % 36).toString(36);
+  return s;
+}
+
+/** Slug de una instalación en una máquina: el mismo cada vez que se calcula (borrar ~/.lienzo no lo cambia). */
+export function slugDeMaquina(maquina, clave) {
+  const h = createHash('sha256').update(`lienzo\0${maquina}\0${clave}`).digest();
+  let s = '';
+  for (let i = 0; i < LARGO_SLUG; i++) s += (h[i] % 36).toString(36);
+  return s;
+}
+
+let maquinaCache;
+/**
+ * Un id estable de esta máquina, o null: IOPlatformUUID en macOS, /etc/machine-id en Linux, MachineGuid en Windows.
+ * No es el hostname (macOS lo cambia solo). Nunca sale de la máquina: solo entra al hash del slug. Se calcula una vez.
+ */
+export function idDeMaquina() {
+  if (maquinaCache !== undefined) return maquinaCache;
+  maquinaCache = null;
+  try {
+    const so = platform();
+    if (so === 'darwin') {
+      const out = execFileSync('/usr/sbin/ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] });
+      maquinaCache = /"IOPlatformUUID"\s*=\s*"([0-9A-Fa-f-]{16,})"/.exec(out)?.[1] ?? null;
+    } else if (so === 'win32') {
+      const out = execFileSync('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf8', timeout: 2000, stdio: ['ignore', 'pipe', 'ignore'] });
+      maquinaCache = /MachineGuid\s+REG_SZ\s+([0-9A-Fa-f-]{16,})/.exec(out)?.[1] ?? null;
+    } else {
+      for (const ruta of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+        try {
+          const v = readFileSync(ruta, 'utf8').trim();
+          if (/^[0-9a-f]{16,}$/i.test(v)) { maquinaCache = v; break; }
+        } catch { /* la siguiente */ }
+      }
+    }
+  } catch {
+    maquinaCache = null;
+  }
+  return maquinaCache;
+}
+
+/** La carpeta de configuración del cliente: CLAUDE_CONFIG_DIR (con ~ expandido) o «predeterminada». */
+export function carpetaDeConfig(env = process.env) {
+  const v = String(env.CLAUDE_CONFIG_DIR ?? '').trim();
+  if (!v) return 'predeterminada';
+  return resolve(v === '~' ? homedir() : v.startsWith('~/') ? join(homedir(), v.slice(2)) : v);
+}
+
+/**
+ * El perfil de Claude Code para el nombre visible: «ontop» de CLAUDE_CONFIG_DIR=~/.claude-ontop; null si no hay
+ * CLAUDE_CONFIG_DIR o es la carpeta de siempre (~/.claude). Así dos perfiles de la misma persona no se llaman igual
+ * en la web («Claude Code (ontop) de Ana» y «Claude Code de Ana»).
+ */
+export function perfilDeConfig(env = process.env) {
+  const v = String(env.CLAUDE_CONFIG_DIR ?? '').trim();
+  if (!v) return null;
+  const p = basename(carpetaDeConfig(env)).replace(/^\.+/, '').replace(/^claude[-_.]?/i, '');
+  const limpio = p.replace(/[^\p{L}\p{N}._-]/gu, '').slice(0, 20);
+  return limpio && limpio.toLowerCase() !== 'claude' ? limpio : null;
+}
+
+/** La clave de una instalación: `<cliente>@<carpeta de config>`. */
+export const claveDeInstalacion = (cliente, env = process.env) => `${cliente || 'claude-code'}@${carpetaDeConfig(env)}`;
+
+function leer(ruta) {
+  try {
+    const d = JSON.parse(readFileSync(ruta, 'utf8'));
+    return d && typeof d === 'object' ? d : null;
+  } catch {
+    return null;
+  }
+}
+
+function escribirAtomico(ruta, datos) {
+  const temporal = `${ruta}.${process.pid}.${randomBytes(4).toString('hex')}.tmp`;
+  try {
+    writeFileSync(temporal, JSON.stringify(datos, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+    renameSync(temporal, ruta);
+  } finally {
+    rmSync(temporal, { force: true });
+  }
+}
+
+/** Guarda la decisión del legado aparte de agente.json (no lanza: sin ella solo se pierde ese recuerdo). */
+function anotarLegado(home, legadoDisponible, legado) {
+  try {
+    escribirAtomico(join(home, ARCHIVO_LEGADO), { legadoDisponible, legado: legado ?? null });
+  } catch (e) {
+    console.error(`[lienzo] no pude guardar ${ARCHIVO_LEGADO} (${e.message})`);
+  }
+}
+
+/**
+ * Al arrancar el puente (constructor de Lienzo): si agente.json no existe, lo crea con `legadoDisponible` = ¿hay
+ * sesion.json en este momento? Se fija una sola vez: si el archivo ya existe no se toca. Si agente.json se borró pero
+ * queda agente.legado.json, se usa esa decisión (y el heredero vuelve a ser el agente de siempre). Devuelve el estado
+ * leído. No lanza: un home que no se puede escribir deja la decisión para `resolverAgente` (que usa el slug de respaldo).
+ */
+export function prepararInstalacion(home) {
+  if (!home) return null;
+  const ruta = join(home, ARCHIVO);
+  try {
+    if (!existsSync(ruta)) {
+      mkdirSync(home, { recursive: true, mode: 0o700 });
+      const previa = leer(join(home, ARCHIVO_LEGADO));
+      const recordada = previa && typeof previa.legadoDisponible === 'boolean';
+      const legadoDisponible = recordada ? previa.legadoDisponible : existsSync(join(home, 'sesion.json'));
+      const legado = recordada && typeof previa.legado === 'string' ? previa.legado : null;
+      const inicial = {
+        version: 1, legadoDisponible, legado,
+        instalaciones: legado ? { [legado]: { agente: null, desde: new Date().toISOString() } } : {},
+      };
+      if (!recordada) anotarLegado(home, legadoDisponible, null);
+      try {
+        // 'wx': si otro proceso lo creó entre medio, gana el suyo (se relee abajo)
+        writeFileSync(ruta, JSON.stringify(inicial, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+      } catch (e) {
+        if (e.code !== 'EEXIST') throw e;
+      }
+    }
+    return leer(ruta);
+  } catch (e) {
+    console.error(`[lienzo] no pude preparar ${ruta} (${e.message}); el id de este agente sale de la clave de la instalación`);
+    return null;
+  }
+}
+
+async function conCandado(home, fn, { esperaMs = CANDADO_ESPERA_MS, viejoMs = CANDADO_VIEJO_MS } = {}) {
+  mkdirSync(home, { recursive: true, mode: 0o700 });
+  const candado = join(home, `${ARCHIVO}.lock`);
+  const hasta = Date.now() + esperaMs;
+  let fd;
+  for (;;) {
+    try {
+      fd = openSync(candado, 'wx', 0o600);
+      break;
+    } catch (e) {
+      if (e.code !== 'EEXIST') throw e;
+      try {
+        if (Date.now() - statSync(candado).mtimeMs > viejoMs) { unlinkSync(candado); continue; }
+      } catch { continue; }
+      if (Date.now() > hasta) throw new Error(`otro proceso tiene tomado ${candado}`);
+      await esperar(25 + Math.random() * 50);
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    closeSync(fd);
+    rmSync(candado, { force: true });
+  }
+}
+
+/** La entrada guardada de una clave, si es válida (null si no hay o está rota). */
+function guardada(d, clave) {
+  const previa = d?.instalaciones && typeof d.instalaciones === 'object' ? d.instalaciones[clave] : null;
+  return previa && (previa.agente === null || RE_SLUG.test(String(previa.agente))) ? previa : null;
+}
+
+/**
+ * Qué agente es esta instalación. Devuelve { agente: slug | null, origen }:
+ *  - 'guardado': ya estaba en agente.json (estable entre arranques)
+ *  - 'legado':   la primera instalación de un home que ya tenía sesión: hereda `{uid}_agente` (agente null)
+ *  - 'nuevo':    slug recién guardado (el de la máquina; aleatorio si la máquina no da un id)
+ *  - 'respaldo': no se pudo leer/escribir agente.json: el slug de la máquina (o uno derivado de la clave)
+ * Lo ya guardado se lee SIN candado: un candado tomado por otro proceso no cambia el id de una instalación que ya lo
+ * tenía (revisión adversarial, 21-10-2026: antes, con el candado tomado más de 10 s, salía un slug de respaldo
+ * distinto). El candado solo se toma para escribir una instalación nueva: dos que se unen a la vez no heredan las
+ * dos el agente de siempre.
+ * `opciones` (para tests): maquina = () => id | null; esperaMs / viejoMs del candado.
+ */
+export async function resolverAgente(home, clave, { maquina = idDeMaquina, esperaMs, viejoMs } = {}) {
+  const ruta = join(home, ARCHIVO);
+  const ya = guardada(leer(ruta), clave);
+  if (ya) return { agente: ya.agente, origen: 'guardado' };
+  const id = maquina();
+  const deMaquina = id ? slugDeMaquina(id, clave) : null;
+  try {
+    return await conCandado(home, async () => {
+      const d = leer(ruta) ?? { version: 1, legadoDisponible: false, legado: null, instalaciones: {} };
+      d.instalaciones = d.instalaciones && typeof d.instalaciones === 'object' ? d.instalaciones : {};
+      const previa = guardada(d, clave);
+      if (previa) return { agente: previa.agente, origen: 'guardado' };
+      let agente;
+      let origen;
+      if (d.legadoDisponible === true && !d.legado) {
+        d.legado = clave;
+        agente = null;
+        origen = 'legado';
+        anotarLegado(home, true, clave);
+      } else {
+        const usados = new Set(Object.values(d.instalaciones).map((i) => i?.agente).filter(Boolean));
+        agente = deMaquina && !usados.has(deMaquina) ? deMaquina : null;
+        while (!agente || usados.has(agente)) agente = nuevoSlug();
+        origen = 'nuevo';
+      }
+      d.instalaciones[clave] = { agente, desde: new Date().toISOString() };
+      escribirAtomico(ruta, d);
+      return { agente, origen };
+    }, { esperaMs, viejoMs });
+  } catch (e) {
+    // otro proceso pudo guardarla mientras esperábamos el candado: lo guardado manda
+    const otra = guardada(leer(ruta), clave);
+    if (otra) return { agente: otra.agente, origen: 'guardado' };
+    console.error(`[lienzo] no pude guardar el id de esta instalación en ${ruta} (${e.message}); uso uno derivado de la ${deMaquina ? 'máquina' : 'clave'}`);
+    return { agente: deMaquina ?? slugDeRespaldo(home, clave), origen: 'respaldo' };
+  }
+}
+
+// ── LIENZO_NOMBRE frente al nombre que se puso desde la web ──────────────────
+// LIENZO_NOMBRE (o el `nombre` de config.json, del plugin o del .mcpb) se aplica cuando el agente entra por primera vez
+// a una sala, o cuando el nombre que tiene ahí lo puso una versión anterior de esa misma variable. Si el nombre de la
+// sala no es ninguno de los que puso la configuración, lo cambió su persona desde la web y se respeta (revisión
+// adversarial, 21-10-2026: antes la variable lo pisaba en cada sesión nueva). Se recuerdan los últimos 10.
+const MAX_NOMBRES = 10;
+
+/** Los nombres que la configuración ya aplicó en esta instalación. */
+export function nombresAplicados(home, clave) {
+  const d = leer(join(home, ARCHIVO));
+  const l = d?.nombres && typeof d.nombres === 'object' ? d.nombres[clave] : null;
+  return Array.isArray(l) ? l.filter((x) => typeof x === 'string') : [];
+}
+
+/** ¿Manda LIENZO_NOMBRE sobre el nombre que el agente ya tiene en la sala? */
+export function nombreDeConfigManda(deConfig, enSala, aplicados) {
+  if (!deConfig) return false;
+  if (!enSala) return true; // entra por primera vez
+  return enSala !== deConfig && aplicados.includes(enSala);
+}
+
+/** Anota que la configuración puso este nombre (no lanza: sin agente.json solo se pierde el recuerdo). */
+export async function anotarNombreAplicado(home, clave, nombre, opciones = {}) {
+  if (!home || !nombre) return;
+  const ruta = join(home, ARCHIVO);
+  if (nombresAplicados(home, clave).at(-1) === nombre) return;
+  try {
+    await conCandado(home, async () => {
+      const d = leer(ruta) ?? { version: 1, legadoDisponible: false, legado: null, instalaciones: {} };
+      d.nombres = d.nombres && typeof d.nombres === 'object' ? d.nombres : {};
+      const l = Array.isArray(d.nombres[clave]) ? d.nombres[clave].filter((x) => typeof x === 'string' && x !== nombre) : [];
+      d.nombres[clave] = [...l, nombre].slice(-MAX_NOMBRES);
+      escribirAtomico(ruta, d);
+    }, opciones);
+  } catch (e) {
+    console.error(`[lienzo] no pude anotar el nombre de la configuración en ${ruta} (${e.message})`);
+  }
+}
+
+// ── el cliente MCP y su nombre visible ──────────────────────────────────────
+
+/** El cliente según el `clientInfo.name` del handshake MCP (null si no se reconoce). */
+export function clienteDeMcp(nombre) {
+  const n = String(nombre ?? '').toLowerCase();
+  if (!n) return null;
+  if (/claude[-\s]?code/.test(n)) return 'claude-code';
+  if (/claude[-\s]?(ai|desktop)/.test(n)) return 'claude-desktop';
+  if (/cursor/.test(n)) return 'cursor';
+  if (/codex/.test(n)) return 'codex';
+  if (/windsurf/.test(n)) return 'windsurf';
+  if (/visual studio code|vscode|copilot/.test(n)) return 'vscode';
+  return null;
+}
+
+const NOMBRES = {
+  'claude-code': 'Claude Code', 'claude-desktop': 'Claude Desktop', cursor: 'Cursor', codex: 'Codex',
+  windsurf: 'Windsurf', vscode: 'VS Code',
+};
+
+/** «Claude Code», «Claude Desktop»…; un cliente desconocido es «Agente» (el nombre de siempre: «Agente de Ana»). */
+export const nombreDeCliente = (cliente) => NOMBRES[cliente] ?? 'Agente';