@dozimple/abap-adt 1.0.0-rc.1

package/dist/tools/transport-risk/risk_extras.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { assertTrkorr } from "../../core/policy.js";
+import { defineTool } from "../../core/tool.js";
+import { callRiskService, RISK_MODULE, sidParam } from "./_service.js";
+/**
+ * El resto de modos del servicio /sap/bc/zdz_risk (DoZimple Transport Risk).
+ * Todos son de solo lectura y devuelven JSON.
+ */
+const months = z.number().int().min(0).max(120).optional().describe("Ventana en meses; 0 = todo el historial");
+const importHealth = defineTool({
+    name: "import_health",
+    title: "Salud de importaciones",
+    description: "Salud de las importaciones de un destino (calidad o productivo): responde «¿cómo van los pases a productivo?». " +
+        "Códigos de retorno: 0 limpio, 4 avisos (normal), ≥8 errores.",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: { target: sidParam("Destino a revisar"), max: z.number().int().min(1).max(500).optional() },
+    run: ({ target, max }, { system }) => callRiskService(system, { mode: "DEV", health: target, max: max?.toString() }),
+});
+const failureRanking = defineTool({
+    name: "failure_ranking",
+    title: "Objetos que más fallan al importar",
+    description: "Ranking de objetos por historial de fallos de importación en un destino. Sirve para saber qué objetos " +
+        "vigilar en un pase y dónde se concentra el riesgo.",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: { target: sidParam("Destino"), months },
+    run: ({ target, months: m }, { system }) => callRiskService(system, { mode: "DEV", ranking: target, months: m?.toString() }),
+});
+const changeAudit = defineTool({
+    name: "change_audit",
+    title: "Evidencia de auditoría de cambios",
+    description: "Evidencia para una auditoría de gestión de cambios en un destino: qué entró, con qué ticket, de qué " +
+        "iniciativa y origen. `tickets`, `iniciativas` y `origenes` son lo que la organización declara y el sistema no " +
+        "puede deducir (p. ej. tickets «CHG,INC,^RFC»; iniciativas «10001=Proyecto demo,^BC=Basis»).",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: {
+        target: sidParam("Destino auditado"),
+        months,
+        tickets: z.string().optional(),
+        iniciativas: z.string().optional(),
+        origenes: z.string().optional(),
+    },
+    run: (a, { system }) => callRiskService(system, {
+        mode: "DEV",
+        audit: a.target,
+        months: a.months?.toString(),
+        tickets: a.tickets,
+        iniciativas: a.iniciativas,
+        origenes: a.origenes,
+    }),
+});
+const objectHistory = defineTool({
+    name: "object_transport_history",
+    title: "Historial de transportes de un objeto",
+    description: "Qué órdenes han tocado un objeto, cuándo, y cuáles llegaron ya al destino. Útil para «¿esto ya está en productivo?» " +
+        "y para encontrar la orden que introdujo un cambio.",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: {
+        object: z.string().min(1).describe("Nombre del objeto"),
+        object_type: z.string().optional().describe("Tipo E071 (REPS, CLAS, FUNC, TABL…). Por defecto REPS"),
+        target: sidParam("Destino contra el que mirar qué llegó"),
+    },
+    run: ({ object, object_type, target }, { system }) => callRiskService(system, { mode: "DEV", history: target, object: object.toUpperCase(), type: object_type?.toUpperCase() }),
+});
+const remoteSource = defineTool({
+    name: "remote_source",
+    title: "Fuente en el destino",
+    description: "La fuente de un objeto TAL COMO ESTÁ en calidad o productivo, leída por el canal de TMS (como «Traer versiones remotas»). " +
+        "Compárala con get_source en DEV para ver qué cambia de verdad con un pase.",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: { object: z.string().min(1), target: sidParam("Sistema del que traer la fuente") },
+    run: ({ object, target }, { system }) => callRiskService(system, { mode: "DEV", remote_source: target, object: object.toUpperCase() }),
+});
+const sourceCheck = defineTool({
+    name: "transport_source_check",
+    title: "Código de una orden contra el destino",
+    description: "Compara el código de los objetos de una orden con el del destino: objetos que no existen allí (R3.4) y deriva " +
+        "de versión — firmas, campos o parámetros distintos que no viajan en la orden (R3.5). Necesita el agente en el " +
+        "destino con S_RFC: si viene `comprobaciones_fallidas`, NO se comprobó (no es «sin riesgos»).",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: { transport_id: z.string(), target: sidParam("Destino") },
+    run: ({ transport_id, target }, { system }) => callRiskService(system, { mode: "DEV", srccheck: target, trkorr: assertTrkorr(transport_id, "transport_id") }),
+});
+export default [importHealth, failureRanking, changeAudit, objectHistory, remoteSource, sourceCheck];
+//# sourceMappingURL=risk_extras.js.map

package/dist/tools/transport-risk/transport_risk.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { ToolError } from "../../core/errors.js";
+import { defineTool } from "../../core/tool.js";
+import { callRiskService, RISK_MODULE, sidParam } from "./_service.js";
+/** Analizador de riesgo de transportes (DoZimple Transport Risk). */
+export default defineTool({
+    name: "analyze_transport_risk",
+    title: "Riesgo de transporte",
+    description: "Dice si una orden (o un pase de varias, separadas por coma) es segura para pasar a calidad o productivo: tareas " +
+        "sin liberar, estado de importación, dependencias que no viajan, acceso posicional, bloqueos del CTS, cola de " +
+        "importación. Primera llamada siempre sin include_source. Un pase se analiza junto, no orden a orden. " +
+        "Con queue_system analiza la cola completa de un destino.",
+    access: "read",
+    requires: { module: RISK_MODULE },
+    input: {
+        transport_id: z.string().optional().describe("Orden o lista separada por coma: DEVK900123,DEVK900124"),
+        check_mode: sidParam("Contra qué sistema comparar: DEV (el propio) o el SID del destino. Si el usuario no lo dice, pregúntalo").default("DEV"),
+        include_source: z.boolean().default(false),
+        include_where_used: z.boolean().default(false).describe("Solo si la orden lleva tablas o estructuras: es lo más caro"),
+        queue_system: sidParam("Analizar la cola de importación de este destino en vez de órdenes").optional(),
+        queue_max: z.number().int().min(1).optional(),
+    },
+    async run(args, { system }) {
+        const ids = String(args.transport_id ?? "")
+            .split(/[,;\s]+/)
+            .map((t) => t.trim().toUpperCase())
+            .filter(Boolean)
+            .join(",");
+        if (args.queue_system) {
+            return callRiskService(system, { mode: args.check_mode, queue: args.queue_system, max: args.queue_max?.toString() });
+        }
+        if (!ids)
+            throw new ToolError("INPUT", "Indica transport_id, o queue_system para analizar la cola de un destino.");
+        return callRiskService(system, {
+            mode: args.check_mode,
+            trkorr: ids,
+            source: args.include_source ? "X" : undefined,
+            where_used: args.include_where_used ? "X" : undefined,
+        });
+    },
+});
+//# sourceMappingURL=transport_risk.js.map

package/docs/THREAT_MODEL.md

@@ -0,0 +1,70 @@
+# Modelo de amenazas — abap-adt-doZimple
+
+Resumen de controles: [SECURITY.md](../SECURITY.md). Este documento explica **contra qué** se diseñaron y **qué
+queda fuera**.
+
+## Alcance y fronteras de confianza
+
+```mermaid
+flowchart LR
+  U["Persona usuaria"] --> C["Cliente MCP<br/>(Claude Code, Kiro…)"]
+  C -- "stdio" --> S["abap-adt-doZimple<br/>(proceso local)"]
+  S -- "HTTPS + usuario SAP personal" --> SAP["Sistemas SAP<br/>DEV / QAS / PRD"]
+  S -- "stdio, entorno mínimo" --> D["Componente de documentación<br/>(proceso aislado)"]
+  D -. "solo si allowOnline y la consulta pasa el filtro" .-> W["Documentación pública"]
+  S --> K["Llavero del SO"]
+  S --> L["Estado local 700/600<br/>uso · huecos · auditoría"]
+```
+
+| Frontera | Qué la cruza | Supuesto |
+|---|---|---|
+| Cliente ↔ servidor | Llamadas a tools y sus respuestas | El modelo **no es de confianza**: puede equivocarse o haber sido manipulado por contenido que leyó |
+| Servidor ↔ SAP | Lecturas y, en DEV habilitado, escrituras | Las autorizaciones SAP del usuario son el límite superior; el servidor solo resta |
+| Servidor ↔ componente de documentación | Consultas conceptuales | El componente es código de terceros: sin credenciales, sin entorno, filtrado |
+| Servidor ↔ internet | Solo consultas de documentación filtradas | Nada del cliente sale; el contenido que entra es no confiable |
+| Equipo local | Configuración, llavero, registros | El equipo y la cuenta del usuario están bajo control del usuario |
+
+## STRIDE
+
+| Amenaza | Escenario | Control | Residual |
+|---|---|---|---|
+| **S**uplantación | Otro proceso lee la contraseña del llavero | Llavero del SO; `--strict` (opt-in) exige confirmación en cada lectura | Sin `--strict`, un proceso del mismo usuario que invoque `security` puede leerla. Solución de raíz prevista: certificado de cliente / SSO (roadmap) |
+| **S**uplantación | TLS interceptado | Verificación TLS; `caFile` | `allowSelfSigned` sigue existiendo como último recurso, marcado |
+| **T**ampering | Cambiar `systems.json` para habilitar escritura o redirigir a otro host | Rechazo si es modificable por otros o de otro usuario | Un proceso del propio usuario puede modificarlo |
+| **T**ampering | Retocar el registro de auditoría | Cadena de hash verificable | Un atacante con la cuenta del usuario puede reescribir la cadena entera; para evidencia fuerte, enviar el registro a un almacén externo (ver roadmap) |
+| **R**epudio | «La IA lo cambió sola» o «no hay constancia de ese cambio» | Confirmación humana con vista previa + auditoría con forma de confirmación y huella del contenido. **Fail-closed**: la intención se registra antes de tocar SAP, y si no se puede registrar (disco lleno, permiso denegado, ruta inválida) la escritura no se ejecuta. Si lo que falla es solo el registro del resultado, la respuesta lo avisa explícitamente. Cubierto por tests que simulan ENOSPC y EACCES | El registro es local; un corte de energía entre intención y resultado deja una intención sin resultado, que se interpreta como «estado desconocido, verificar en SAP» |
+| **I**nformation disclosure | Leer hashes, almacén seguro, PSE, OAuth, dumps | Veto directo y a través de vistas y CDS | Tablas Z que copien esos datos no se detectan por nombre |
+| **I**nformation disclosure | Volcar datos personales al proveedor LLM | Clase de datos, enmascarado, tope de filas | Columnas personales con nombres no estándar (Z) no se enmascaran; el tope limita el volumen |
+| **I**nformation disclosure | Nombres de cliente u objetos Z hacia internet | Online apagado; filtro de consultas e ids | Un concepto puede describir un proceso de negocio sin nombrarlo |
+| **D**enegación de servicio | Consultas enormes o bucles del agente contra SAP | Topes de filas, de salida (80k) y de objetos; timeouts | Un where-used masivo sigue costando ~1 min al servidor SAP |
+| **E**levación de privilegios | Escribir en QAS/PRD o ejecutar código fuera de DEV | Política por rol independiente de la configuración de escritura | — |
+| **E**levación de privilegios | Test ABAP Unit peligroso | Solo HARMLESS / SHORT | Un test mal clasificado por su autor como HARMLESS |
+
+## OWASP Top 10 para aplicaciones LLM (2025)
+
+| Riesgo | Cómo aplica a un MCP de SAP | Control |
+|---|---|---|
+| LLM01 Prompt injection | Comentarios en fuente ABAP, textos, datos de tablas, documentación o posts de comunidad con instrucciones | Marca de «dato, nunca instrucciones» en toda respuesta; ninguna escritura sin confirmación humana; tools de escritura destructivas para el cliente |
+| LLM02 Divulgación de información sensible | Datos personales y material de seguridad en respuestas que llegan al proveedor | Vetos, enmascarado, tope de filas, filtro de salida a internet |
+| LLM03 Cadena de suministro | Dependencias npm, MCP de terceros | Versiones exactas, firmas, SBOM, `ignore-scripts`, terceros aislados tras revisión |
+| LLM05 Manejo inadecuado de la salida | El agente usa una respuesta como si fuera verdad | Errores tipados que nunca parecen vacíos; «tope alcanzado» explícito; calidad de la evidencia en diffs |
+| LLM06 Agencia excesiva | El agente escribe, activa o crea órdenes por su cuenta | Mínimo privilegio por tool y rol; escritura desactivada por defecto; confirmación con vista previa; sin liberar, importar ni borrar |
+| LLM07 Filtrado del prompt de sistema | — | El servidor no tiene prompts secretos; las recetas guiadas son públicas |
+| LLM08 Debilidades de vectores y embeddings | Índice local de documentación | Solo documentación pública; ningún dato del cliente se indexa |
+| LLM09 Desinformación | Afirmar que algo está en productivo sin comprobarlo | Honestidad de errores; comprobación real contra SAP (sintaxis, versiones, cola de importación) |
+| LLM10 Consumo sin límites | Respuestas enormes, bucles | Topes de salida, filas y objetos |
+
+## Fuera de alcance
+
+- Compromiso de la cuenta del usuario o del equipo.
+- Autorizaciones SAP mal diseñadas: el servidor no las sustituye.
+- Lo que el proveedor del modelo haga con las respuestas: se reduce lo que se le envía, no se controla su lado.
+- Transportes y cambios hechos fuera de este servidor (SE80, Eclipse, abap-fs).
+
+## Roadmap de seguridad
+
+- **Autenticación sin contraseña reutilizable** (Sprint 2): certificado de cliente X.509 y SSO (SAML / principal
+  propagation) hacia ADT, para que no exista un secreto que leer del llavero.
+- Envío opcional del registro de auditoría a un almacén externo o SIEM (append-only fuera del equipo).
+- Diccionario de columnas personales ampliable por configuración (campos Z).
+- Firma de las versiones publicadas (procedencia npm / Sigstore) si se distribuye como paquete.