@dozimple/abap-adt 1.0.0 → 1.1.0

package/dist/core/config.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
@@ -34,6 +35,11 @@ const SystemSchema = z.object({
     dataClass: z.enum(["test", "masked", "prod"]).optional(),
     /** Tope de filas por consulta; por defecto test 5000, masked 1000, prod 200. */
     maxRows: z.number().int().min(1).max(5000).optional(),
+    /**
+     * Columnas personales propias de este cliente (campos Z o alias de CDS) que se enmascaran igual que las estándar
+     * en sistemas masked/prod. El enmascarado es por nombre: lo que no esté aquí ni en la lista estándar sale en claro.
+     */
+    piiColumns: z.array(z.string().regex(/^[A-Za-z0-9_/]+$/)).default([]),
     password: z
         .string()
         .regex(/^(keychain|env:[A-Z0-9_]+)$/, 'password: "keychain" o "env:NOMBRE_VARIABLE"')
@@ -70,6 +76,12 @@ export function parseConfig(raw) {
             throw new Error(`Sistema duplicado en la configuración: ${s.id}`);
         ids.add(key);
     }
+    for (const s of cfg.systems) {
+        // Sin verificar TLS, quien intercepte la red recibe usuario y contraseña (Basic): nunca en calidad ni productivo.
+        if (s.allowSelfSigned && s.role !== "DEV") {
+            throw new Error(`${s.id}: allowSelfSigned solo se admite en sistemas DEV. Para ${s.role} usa caFile con el certificado de su CA.`);
+        }
+    }
     if (cfg.defaultSystem && !ids.has(cfg.defaultSystem.toUpperCase())) {
         throw new Error(`defaultSystem "${cfg.defaultSystem}" no está en systems[]`);
     }
@@ -88,8 +100,9 @@ export function loadConfig(path = configPath()) {
  * servidor y si puede escribir en él: tiene que ser solo del usuario.
  */
 export function assertPrivateFile(path, st = statSync(path)) {
+    // En Windows no hay bits de modo ni uid: se leen las ACL (assertPrivateFileWindows).
     if (process.platform === "win32")
-        return;
+        return assertPrivateFileWindows(path);
     if (st.mode & 0o022) {
         throw new Error(`${path} lo pueden modificar otros usuarios (permisos ${(st.mode & 0o777).toString(8)}). Corrígelo con: chmod 600 "${path}"`);
     }
@@ -98,6 +111,69 @@ export function assertPrivateFile(path, st = statSync(path)) {
         throw new Error(`${path} pertenece a otro usuario (uid ${st.uid}). Debe ser tuyo y con permisos 600.`);
     }
 }
+// ── Windows: ACL del archivo ────────────────────────────────────────────────
+/** Quién puede escribir legítimamente, además del propio usuario: SYSTEM, Administradores, TrustedInstaller. */
+const TRUSTED_SIDS = new Set(["S-1-5-18", "S-1-5-32-544", "S-1-5-80-956008885-3418522649-1831038044-1853292631-2271478464"]);
+/** Derechos que permiten cambiar el contenido, los permisos o el propietario (nombres de .NET y genéricos numéricos). */
+const WRITE_RIGHTS = /FullControl|Modify|Write|AppendData|CreateFiles|ChangePermissions|TakeOwnership|^(268435456|1073741824)$/;
+/** Entradas que dan escritura a alguien que no es el usuario ni una identidad del sistema. */
+export function aclViolations(entries, userSid) {
+    return entries.filter((e) => /allow/i.test(e.type) && e.sid !== userSid && !TRUSTED_SIDS.has(e.sid) && WRITE_RIGHTS.test(e.rights));
+}
+/** Salida del script de PowerShell: «USER|<sid>», «OWNER|<sid>» y «ACE|<sid>|<derechos>|<tipo>». */
+export function parseAclOutput(out) {
+    let user = "";
+    let owner = "";
+    const entries = [];
+    for (const line of out.split(/\r?\n/)) {
+        const [kind, sid, rights, type] = line.trim().split("|");
+        if (kind === "USER")
+            user = sid;
+        else if (kind === "OWNER")
+            owner = sid;
+        else if (kind === "ACE" && sid)
+            entries.push({ sid, rights: rights ?? "", type: type ?? "" });
+    }
+    return { user, owner, entries };
+}
+// La ruta llega por variable de entorno, nunca dentro del comando: sin inyección posible.
+const ACL_SCRIPT = [
+    "$ErrorActionPreference='Stop'",
+    "$a=Get-Acl -LiteralPath $env:ABAPDZ_ACL_PATH",
+    "'USER|'+[Security.Principal.WindowsIdentity]::GetCurrent().User.Value",
+    "'OWNER|'+(New-Object Security.Principal.NTAccount($a.Owner)).Translate([Security.Principal.SecurityIdentifier]).Value",
+    "foreach($r in $a.Access){ $s=try{$r.IdentityReference.Translate([Security.Principal.SecurityIdentifier]).Value}catch{$r.IdentityReference.Value}; 'ACE|'+$s+'|'+$r.FileSystemRights+'|'+$r.AccessControlType }",
+].join("; ");
+/**
+ * systems.json define qué proceso lanza cada componente (sidecars.command): quien pueda escribirlo ejecuta código
+ * con tu identidad. En Windows se exige que solo tu usuario (y el sistema) pueda modificarlo. Si la comprobación no
+ * se puede hacer, no se arranca (fail-closed), salvo ABAP_DZ_SKIP_ACL_CHECK=1, que queda avisado al arrancar.
+ */
+export function assertPrivateFileWindows(path, run = () => execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", ACL_SCRIPT], {
+    encoding: "utf8",
+    timeout: 15_000,
+    env: { ...process.env, ABAPDZ_ACL_PATH: path },
+})) {
+    if (process.env.ABAP_DZ_SKIP_ACL_CHECK === "1")
+        return;
+    let acl;
+    try {
+        acl = parseAclOutput(run());
+    }
+    catch (e) {
+        throw new Error(`No se pudieron leer los permisos de ${path} (${e.message.split("\n")[0]}). Sin esa comprobación no se arranca; si lo asumes, define ABAP_DZ_SKIP_ACL_CHECK=1.`);
+    }
+    if (!acl.user)
+        throw new Error(`No se pudo determinar el usuario actual para comprobar ${path}.`);
+    if (acl.owner && acl.owner !== acl.user && !TRUSTED_SIDS.has(acl.owner)) {
+        throw new Error(`${path} pertenece a otra identidad (${acl.owner}). Debe ser tuyo.`);
+    }
+    const bad = aclViolations(acl.entries, acl.user);
+    if (bad.length) {
+        throw new Error(`${path} lo pueden modificar otras identidades (${bad.map((b) => `${b.sid}: ${b.rights}`).join("; ")}). ` +
+            `Déjalo solo para tu usuario: icacls "${path}" /inheritance:r /grant:r "%USERNAME%":F`);
+    }
+}
 /** Escritura efectiva: hace falta allowWrite y ser un sistema de desarrollo. */
 export function canWrite(s) {
     return s.allowWrite && s.role === "DEV";
@@ -133,4 +209,16 @@ export function resolveSystem(cfg, requested) {
         return { system: cfg.systems[0], source: "único configurado" };
     throw new Error(`Hay varios sistemas y ninguno por defecto: indica "system" (${cfg.systems.map((x) => x.id).join(", ")})`);
 }
+/** Avisos que se escriben por stderr en cada arranque: lo que la configuración deja más débil de lo normal. */
+export function startupWarnings(cfg, platform = process.platform) {
+    const out = [];
+    for (const s of cfg.systems) {
+        if (s.allowSelfSigned && !s.caFile)
+            out.push(`${s.id}: TLS SIN VERIFICAR (allowSelfSigned). Configura caFile con el certificado de su CA.`);
+    }
+    if (platform === "win32" && process.env.ABAP_DZ_SKIP_ACL_CHECK === "1") {
+        out.push("Windows: ABAP_DZ_SKIP_ACL_CHECK=1 desactiva la comprobación de permisos de systems.json (que define los procesos que se lanzan). Quítala en cuanto puedas.");
+    }
+    return out;
+}
 //# sourceMappingURL=config.js.map

package/dist/core/confirm.js

@@ -22,22 +22,34 @@ function canonical(v) {
 export function argsDigest(tool, system, args) {
     return createHash("sha256").update(JSON.stringify([tool, system.toUpperCase(), canonical(args)])).digest("hex");
 }
-export function issueToken(tool, system, args, now = Date.now()) {
+/**
+ * `state` es la huella de lo que el usuario vio en la vista previa (p. ej. el sha256 de la fuente actual en SAP):
+ * la tool la compara al escribir para no aplicar un diff sobre algo que cambió entretanto.
+ */
+export function issueToken(tool, system, args, now = Date.now(), state) {
     for (const [t, p] of pending)
         if (p.exp <= now)
             pending.delete(t);
     const token = randomBytes(16).toString("hex");
-    pending.set(token, { digest: argsDigest(tool, system, args), exp: now + CONFIRM_TTL_MS });
+    pending.set(token, { digest: argsDigest(tool, system, args), exp: now + CONFIRM_TTL_MS, state });
     return token;
 }
-/** Consume el token: vale una sola vez, también cuando no coincide. */
-export function consumeToken(token, tool, system, args, now = Date.now()) {
+/** Como consumeToken, y además devuelve la huella del estado que se vio en la vista previa. */
+export function consumeTokenWithState(token, tool, system, args, now = Date.now()) {
     const p = pending.get(token);
     if (!p)
-        return "unknown";
+        return { check: "unknown" };
     pending.delete(token);
     if (p.exp <= now)
-        return "expired";
-    return p.digest === argsDigest(tool, system, args) ? "ok" : "mismatch";
+        return { check: "expired" };
+    return p.digest === argsDigest(tool, system, args) ? { check: "ok", state: p.state } : { check: "mismatch" };
+}
+/** Consume el token: vale una sola vez, también cuando no coincide. */
+export function consumeToken(token, tool, system, args, now = Date.now()) {
+    return consumeTokenWithState(token, tool, system, args, now).check;
+}
+/** Huella de un contenido tal como se mostró: sha256 con saltos de línea normalizados. */
+export function stateOf(content) {
+    return createHash("sha256").update(content.replace(/\r\n?/g, "\n")).digest("hex");
 }
 //# sourceMappingURL=confirm.js.map

package/dist/core/connection.js

@@ -8,6 +8,10 @@ import { normalizeValue, wrapSql } from "./sql.js";
 const CACHE_DIR = join(homedir(), ".cache", "abap-adt-dozimple");
 const DISCOVERY_TTL_MS = 7 * 24 * 3600 * 1000;
 const REQUEST_TIMEOUT_MS = 120_000;
+/** Circuit breaker: N fallos de red en la ventana abren el circuito durante CIRCUIT_OPEN_MS. */
+const CIRCUIT_FAILURES = 3;
+const CIRCUIT_WINDOW_MS = 60_000;
+const CIRCUIT_OPEN_MS = 60_000;
 /**
  * TLS: con caFile se verifica contra ese certificado (lo correcto para un
  * sistema con certificado propio); allowSelfSigned desactiva la verificación
@@ -30,9 +34,44 @@ export class SapConnection {
     reader;
     caps;
     basisRelease;
+    networkFailures = [];
+    openUntil = 0;
     constructor(system) {
         this.system = system;
     }
+    /** Olvida el cliente de lectura (sesión caducada): la siguiente llamada vuelve a entrar. */
+    resetReader() {
+        const old = this.reader;
+        this.reader = undefined;
+        old?.then((c) => c.logout()).catch(() => undefined);
+    }
+    /**
+     * Tres fallos de red en un minuto abren el circuito: durante un minuto ninguna tool intenta nada contra este
+     * sistema y responde al instante. Un sistema caído (VPN, host) dejaba de responder 120 s por cada llamada.
+     */
+    noteNetworkFailure(now = Date.now()) {
+        this.networkFailures = this.networkFailures.filter((t) => now - t < CIRCUIT_WINDOW_MS);
+        this.networkFailures.push(now);
+        if (this.networkFailures.length >= CIRCUIT_FAILURES) {
+            this.openUntil = now + CIRCUIT_OPEN_MS;
+            this.networkFailures = [];
+        }
+    }
+    /** Segundos que faltan para volver a intentar, o 0 si el circuito está cerrado. */
+    circuitOpenFor(now = Date.now()) {
+        return this.openUntil > now ? Math.ceil((this.openUntil - now) / 1000) : 0;
+    }
+    /** Cierra el circuito a mano (sap_systems con check): se vuelve a intentar ya. */
+    resetCircuit() {
+        this.openUntil = 0;
+        this.networkFailures = [];
+    }
+    assertCircuitClosed() {
+        const s = this.circuitOpenFor();
+        if (s) {
+            throw new ToolError("NETWORK", `${this.system.id} no respondió ${CIRCUIT_FAILURES} veces seguidas: no se vuelve a intentar durante ${s} s.`, "sap_systems(check=true) lo reintenta ahora mismo.");
+        }
+    }
     async newClient() {
         const s = this.system;
         const password = await getPassword(s);
@@ -53,6 +92,7 @@ export class SapConnection {
     }
     /** Cliente de lectura, reutilizado entre llamadas. */
     async adt() {
+        this.assertCircuitClosed();
         if (!this.reader) {
             this.reader = this.newClient().then((c) => this.login(c));
             this.reader.catch(() => (this.reader = undefined));
@@ -61,6 +101,7 @@ export class SapConnection {
     }
     /** Ejecuta fn con una sesión stateful propia y la cierra siempre. */
     async stateful(fn) {
+        this.assertCircuitClosed();
         const c = await this.login(await this.newClient());
         c.stateful = session_types.stateful;
         try {
@@ -88,7 +129,11 @@ export class SapConnection {
         if (!this.basisRelease) {
             this.basisRelease = this.query("SELECT release FROM cvers WHERE component = 'SAP_BASIS'", 1)
                 .then((r) => r.values[0]?.RELEASE?.trim())
-                .catch(() => undefined);
+                .catch(() => {
+                // Un fallo pasajero (VPN caída un instante) no deja el dato en blanco para siempre: se reintenta después.
+                this.basisRelease = undefined;
+                return undefined;
+            });
         }
         return this.basisRelease;
     }

package/dist/core/credentials.js

@@ -4,6 +4,8 @@ import { ToolError } from "./errors.js";
 const run = promisify(execFile);
 /** Servicio del llavero de macOS bajo el que se guardan las contraseñas. */
 export const KEYCHAIN_SERVICE = "abap-adt-dozimple";
+/** Contraseñas en memoria con caducidad: sin caché el llavero se leería en cada petición; sin límite, vivirían siempre. */
+const CACHE_TTL_MS = 15 * 60_000;
 const cache = new Map();
 /**
  * Devuelve la contraseña del sistema. Nunca se escribe en logs ni en la
@@ -11,8 +13,9 @@ const cache = new Map();
  */
 export async function getPassword(s) {
     const hit = cache.get(s.id);
-    if (hit)
-        return hit;
+    if (hit && hit.exp > Date.now())
+        return hit.pwd;
+    cache.delete(s.id);
     let pwd;
     if (s.password.startsWith("env:")) {
         pwd = process.env[s.password.slice(4)];
@@ -34,11 +37,15 @@ export async function getPassword(s) {
             throw new ToolError("AUTH", `No hay contraseña para ${s.id} en el llavero. Guárdala con: scripts/set-password.sh ${s.id}`);
         }
     }
-    cache.set(s.id, pwd);
+    cache.set(s.id, { pwd, exp: Date.now() + CACHE_TTL_MS });
     return pwd;
 }
 /** Tras un 401 conviene olvidar la contraseña cacheada por si se cambió. */
 export function forgetPassword(id) {
     cache.delete(id);
 }
+/** Al cerrar el servidor: ninguna contraseña queda en memoria más de lo necesario. */
+export function clearPasswords() {
+    cache.clear();
+}
 //# sourceMappingURL=credentials.js.map

package/dist/core/datapolicy.js

@@ -1,6 +1,6 @@
 import { normalizeError, ToolError } from "./errors.js";
-import { sqlLiteral } from "./objects.js";
-import { assertNotSensitive, assertSelectOnly, rejectSensitive, sensitiveHits, sqlWords } from "./policy.js";
+import { adtPathName, sqlLiteral } from "./objects.js";
+import { assertNotSensitive, assertSelectOnly, rejectSensitive, SENSITIVE_COLUMNS, sensitiveHits, sqlWords } from "./policy.js";
 export const dataClassOf = (s) => s.dataClass ?? (s.role === "DEV" ? "test" : "prod");
 const DEFAULT_CAP = { test: 5000, masked: 1000, prod: 200 };
 export const rowCap = (s) => s.maxRows ?? DEFAULT_CAP[dataClassOf(s)];
@@ -24,17 +24,18 @@ export const MASK = "‹oculto›";
  * simple, para enmascararla. Usarla en un WHERE, un alias o una expresión
  * dejaría deducir su valor sin que aparezca en el resultado.
  */
-export function maskPii(cls, sql, columns, rows) {
+export function maskPii(cls, sql, columns, rows, extra = []) {
     if (cls === "test")
         return [];
+    const pii = extra.length ? new Set([...PII_COLUMNS, ...extra.map((c) => c.toUpperCase())]) : PII_COLUMNS;
     const cols = new Set(columns.map((c) => c.toUpperCase()));
-    const mentioned = new Set(sqlWords(sql).flatMap((w) => w.split("~")).filter((w) => PII_COLUMNS.has(w)));
+    const mentioned = new Set(sqlWords(sql).flatMap((w) => w.split("~")).filter((w) => pii.has(w)));
     const hidden = [...mentioned].filter((w) => !cols.has(w));
     if (hidden.length) {
         throw new ToolError("POLICY", `En un sistema con datos ${cls === "prod" ? "productivos" : "enmascarados"}, las columnas personales (${hidden.join(", ")}) ` +
             `solo pueden pedirse como columna simple del SELECT: no en WHERE, alias ni expresiones.`, "Filtra por la clave (KUNNR, LIFNR, PARTNER…) y deja que la columna salga enmascarada, o consulta un sistema de test.");
     }
-    const masked = columns.filter((c) => PII_COLUMNS.has(c.toUpperCase()));
+    const masked = columns.filter((c) => pii.has(c.toUpperCase()));
     for (const row of rows)
         for (const c of masked)
             if (row[c] !== "" && row[c] !== null && row[c] !== undefined)
@@ -116,7 +117,7 @@ export async function assertNoSensitiveViews(sap, sql, depth = 3) {
                 for (const [ddl, objs] of byDdl) {
                     let src;
                     try {
-                        src = await c.getObjectSource(`/sap/bc/adt/ddic/ddl/sources/${encodeURIComponent(ddl.toLowerCase())}/source/main`);
+                        src = await c.getObjectSource(`/sap/bc/adt/ddic/ddl/sources/${adtPathName(ddl)}/source/main`);
                     }
                     catch (e) {
                         throw new ToolError("POLICY", `No se pudo comprobar qué tablas lee la CDS ${ddl} (${normalizeError(e).message}): la consulta no se ejecuta sin esa comprobación.`);
@@ -160,8 +161,15 @@ export async function guardedQuery(sap, system, sql, requestedRows) {
     const cap = Math.min(requestedRows, rowCap(system));
     const r = await sap.query(q, cap);
     const columns = r.columns.map((c) => c.name);
+    // «SELECT *» no nombra las columnas: el veto se aplica también a lo que DEVUELVE SAP. Si llega alguna vetada, se
+    // descarta el resultado entero antes de mostrar nada.
+    const vetoed = columns.filter((c) => SENSITIVE_COLUMNS.includes(c.toUpperCase()));
+    if (vetoed.length) {
+        r.values.length = 0;
+        throw new ToolError("POLICY", `Consulta bloqueada: el resultado incluye columnas de credenciales (${vetoed.join(", ")}). Pide las columnas concretas que necesitas, sin esas.`);
+    }
     const notes = [];
-    const masked = maskPii(cls, q, columns, r.values);
+    const masked = maskPii(cls, q, columns, r.values, system.piiColumns ?? []);
     if (masked.length)
         notes.push(`Columnas personales enmascaradas (sistema con datos ${cls === "prod" ? "productivos" : "enmascarados"}): ${masked.join(", ")}.`);
     const capped = r.values.length >= cap;

package/dist/core/errors.js

@@ -19,26 +19,29 @@ export function normalizeError(e, systemId) {
     if (e instanceof ToolError)
         return e;
     const any = e;
+    // signal.throwIfAborted() entre pasos de una tool larga: cancelación del cliente, no fallo del servidor.
+    if (any?.name === "AbortError")
+        return new ToolError("CANCELLED", "Cancelado por el cliente antes de terminar.");
     const code = errCode(any);
     if (code && NETWORK_CODES.has(code)) {
         return new ToolError("NETWORK", `No se llega a ${systemId ?? "SAP"} (${code}).`, "¿Está levantada la VPN de ese cliente?");
     }
     if (isCsrfError(e)) {
-        return new ToolError("AUTH", `Sesión o token CSRF rechazado por ${systemId ?? "SAP"}: ${any.message}`);
+        return new ToolError("AUTH", `Sesión o token CSRF rechazado por ${systemId ?? "SAP"}: ${sanitizeMessage(any.message)}`);
     }
     if (isHttpError(e)) {
         const st = any.status;
         if (st === 401)
             return new ToolError("AUTH", `Usuario o contraseña rechazados por ${systemId ?? "SAP"} (401).`);
         if (st === 403)
-            return new ToolError("AUTH", `Sin autorización (403): ${any.message}`);
+            return new ToolError("AUTH", `Sin autorización (403): ${sanitizeMessage(any.message)}`);
         if (st === 404)
-            return new ToolError("NOT_FOUND", `No encontrado (404): ${any.message}`);
-        return new ToolError("SAP", `HTTP ${st ?? "?"}: ${any.message}`);
+            return new ToolError("NOT_FOUND", `No encontrado (404): ${sanitizeMessage(any.message)}`);
+        return new ToolError("SAP", `HTTP ${st ?? "?"}: ${sanitizeMessage(any.message)}`);
     }
     if (isAdtError(e)) {
         const st = any.err;
-        const msg = any.localizedMessage || any.message || "sin mensaje";
+        const msg = sanitizeMessage(any.localizedMessage || any.message || "sin mensaje", 1500);
         if (st === 401)
             return new ToolError("AUTH", `Usuario o contraseña rechazados (401): ${msg}`);
         if (st === 403)
@@ -47,9 +50,19 @@ export function normalizeError(e, systemId) {
             return new ToolError("NOT_FOUND", msg);
         return new ToolError("SAP", `${msg}${st ? ` (HTTP ${st})` : ""}`);
     }
-    const message = any?.message ? String(any.message) : String(e);
+    const message = sanitizeMessage(any?.message ? String(any.message) : String(e));
     return new ToolError("INTERNAL", message || "Error sin mensaje");
 }
+/**
+ * Sesión caducada a mitad de una lectura: token CSRF rechazado, o 401 en una sesión que ya había entrado. El registro
+ * la renueva y repite la lectura UNA vez; nunca una escritura (el bloqueo se perdió con la sesión).
+ */
+export function isSessionExpired(e) {
+    if (isCsrfError(e))
+        return true;
+    const st = e;
+    return (isHttpError(e) && st?.status === 401) || (isAdtError(e) && st?.err === 401);
+}
 export function renderError(te) {
     const labels = {
         NETWORK: "Sin conexión",
@@ -60,9 +73,24 @@ export function renderError(te) {
         CAPABILITY: "No disponible en este sistema",
         MODULE: "Módulo no habilitado",
         INPUT: "Parámetros inválidos",
+        CANCELLED: "Cancelado",
         INTERNAL: "Error interno",
     };
     return `${labels[te.kind]}: ${te.message}${te.hint ? `\n${te.hint}` : ""}\n` +
         `(No se completó la operación: no interpretes esto como un resultado vacío.)`;
 }
+/**
+ * Texto de error apto para llegar al modelo (y por tanto al proveedor LLM): sin credenciales incrustadas en URLs,
+ * sin cabeceras Authorization, sin marcado y con longitud acotada. Los errores de SAP o de HTTP pueden traer rutas,
+ * hosts o páginas de error enteras; aquí se reducen a lo útil para diagnosticar.
+ */
+export function sanitizeMessage(msg, max = 500) {
+    const clean = String(msg)
+        .replace(/\b([a-z][a-z0-9+.-]*:\/\/)[^\s:@/]+:[^\s@/]+@/gi, "$1[credenciales]@")
+        .replace(/(authorization["']?\s*[:=]\s*["']?)(basic|bearer)\s+[A-Za-z0-9+/=._-]+/gi, "$1$2 [oculto]")
+        .replace(/<[^>]{0,200}>/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    return clean.length > max ? clean.slice(0, max) + "…" : clean;
+}
 //# sourceMappingURL=errors.js.map

package/dist/core/feeds.js

@@ -39,7 +39,17 @@ export function parseAtom(xml) {
         };
     });
 }
+/** Tope de entrada antes de sanear: el saneado repite pasadas y el HTML de un dump puede ser enorme. */
+export const MAX_HTML_INPUT = 2 * 1024 * 1024;
+/**
+ * Tras decodificar entidades, «&lt;script&gt;» vuelve a ser «<script>». Este servidor no renderiza HTML, pero un
+ * cliente MCP podría, y el contenido de SAP podría imitar así el formato de las respuestas del servidor: se
+ * neutraliza todo «<» que abra algo con forma de etiqueta. Un «a < b» del texto se conserva.
+ */
+export const neutralizeMarkup = (s) => s.replace(/<(?=[A-Za-z!/?])/g, "‹");
 export function htmlToText(html) {
+    if (html.length > MAX_HTML_INPUT)
+        html = html.slice(0, MAX_HTML_INPUT) + "\n[… contenido recortado]";
     let noScripts = html;
     for (let prev = ""; prev !== noScripts;) {
         prev = noScripts;
@@ -49,7 +59,7 @@ export function htmlToText(html) {
         .replace(/<br\s*\/?>/gi, "\n")
         .replace(/<\/(p|div|h\d|li|tr|table)>/gi, "\n")
         .replace(/<\/t[dh]>/gi, "\t");
-    return decodeEntities(stripTags(withBreaks))
+    return neutralizeMarkup(decodeEntities(stripTags(withBreaks)))
         .replace(/\r\n?/g, "\n")
         .replace(/[ \t]+\n/g, "\n")
         .replace(/\n[ \t]+/g, "\n")

package/dist/core/objects.js

@@ -136,6 +136,16 @@ export async function resolveByTypePrefix(c, name, prefixes) {
     const h = hits.find((x) => x["adtcore:name"].toUpperCase() === name.toUpperCase() && prefixes.some((t) => x["adtcore:type"].startsWith(t)));
     return h ? { uri: h["adtcore:uri"], type: h["adtcore:type"] } : undefined;
 }
+/**
+ * Nombre de objeto apto para una ruta ADT. encodeURIComponent no codifica «.», así que «..» sobreviviría y
+ * recorrería la ruta; un nombre de repositorio ABAP solo tiene letras, dígitos, «_», «$» y namespaces «/X/».
+ */
+export function adtPathName(name) {
+    const n = name.trim();
+    if (!/^(\/[A-Za-z0-9_]+\/)?[A-Za-z0-9_$]{1,40}$/.test(n))
+        throw new ToolError("INPUT", `Nombre de objeto inválido para una ruta ADT: ${name}`);
+    return encodeURIComponent(n.toLowerCase());
+}
 /** Escapa un literal para ABAP SQL. */
 export function sqlLiteral(v) {
     return `'${v.replace(/'/g, "''")}'`;

package/dist/core/policy.js

@@ -41,7 +41,11 @@ export const SENSITIVE_TABLES = [
     "USRACL", "SNAP",
 ];
 export const SENSITIVE_PREFIXES = ["OA2C_"];
-export const SENSITIVE_COLUMNS = ["PWDSALTEDHASH", "BCODE", "PASSCODE"];
+/**
+ * Columnas con contraseñas o sus hashes, en cualquier tabla: además de las de USR02, la contraseña del usuario de
+ * inicio de sesión fijo de un servicio ICF (ICFSERVICE-ICF_PASSWD) y nombres genéricos de columna de contraseña.
+ */
+export const SENSITIVE_COLUMNS = ["PWDSALTEDHASH", "BCODE", "PASSCODE", "ICF_PASSWD", "PASSWD", "PASSWORD"];
 /** Datos de personal (infotipos, clusters de nómina): categoría especial, nunca por este servidor. */
 export const HR_TABLE_RE = /^(PA\d{4}|PB\d{4}|PCL[1-5]|HRPY_[A-Z0-9_]+)$/;
 /** Qué palabras de una consulta (o de una definición de vista) son material vetado. */
@@ -116,6 +120,11 @@ export function assertPublicQuery(query, cfg, blockTerms = []) {
         throw new ToolError("POLICY", `La consulta saldría a internet con datos del cliente o del sistema (${[...new Set(hits)].join(", ")}).`, "Reformúlala con el concepto técnico (p. ej. «MATNR length extension BAPI»), sin nombres Z, órdenes, sistemas ni clientes; o búscala sin online.");
     }
 }
+/**
+ * Usuario SAP: hasta 12 caracteres (USR02-BNAME). Se interpola en filtros de feeds ADT (dumps, errores de Gateway):
+ * paréntesis, comas o espacios podrían reescribir la expresión del filtro, así que solo se admite esta forma.
+ */
+export const SAP_USER_RE = /^[A-Za-z0-9_.@-]{1,12}$/;
 export const TRKORR_RE = /^[A-Z0-9]{3}K\d{6}$/;
 export function assertTrkorr(t, label = "transport") {
     const up = t.trim().toUpperCase();