balizamcp 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 granero
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,225 @@
+# balizamcp
+
+[![npm version](https://badge.fury.io/js/balizamcp.svg)](https://www.npmjs.com/package/balizamcp)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-blue)](https://modelcontextprotocol.io)
+[![balizame.com](https://img.shields.io/badge/balizame.com-official-orange)](https://balizame.com)
+
+**Servidor MCP oficial de [balizame.com](https://balizame.com) para datos en tiempo real de balizas V16 activas en Espana.**
+
+Conecta Claude y otros LLMs con el [Punto de Acceso Nacional (NAP)](https://nap.dgt.es) de la DGT, obteniendo las ubicaciones de vehiculos detenidos/averiados que estan transmitiendo su posicion mediante balizas V16 conectadas
+
+---
+
+## Caracteristicas
+
+- **Datos en tiempo real**: Actualizacion cada minuto desde el NAP de la DGT
+- **Filtrado inteligente**: Solo muestra incidentes tipo `vehicleObstruction` (balizas V16 activas)
+- **Cobertura nacional**: Todas las balizas V16 conectadas en Espana
+- **Informacion completa**: Coordenadas GPS, carretera, km, municipio, provincia, severidad
+- **Cache inteligente**: Minimiza llamadas al servidor respetando la frecuencia de actualizacion
+
+## Instalacion
+
+### Opcion 1: npx (recomendado)
+
+No necesitas instalar nada, usalo directamente:
+
+```bash
+npx balizamcp
+```
+
+### Opcion 2: Instalacion global
+
+```bash
+npm install -g balizamcp
+```
+
+### Opcion 3: Desde codigo fuente
+
+```bash
+git clone https://github.com/granero/balizamcp.git
+cd balizamcp
+npm install
+npm run build
+```
+
+## Configuracion en Claude Desktop
+
+Anade a tu archivo de configuracion `claude_desktop_config.json`:
+
+### macOS
+```
+~/Library/Application Support/Claude/claude_desktop_config.json
+```
+
+### Windows
+```
+%APPDATA%\Claude\claude_desktop_config.json
+```
+
+### Configuracion
+
+```json
+{
+  "mcpServers": {
+    "balizas-v16": {
+      "command": "npx",
+      "args": ["-y", "balizamcp"]
+    }
+  }
+}
+```
+
+O si lo instalaste globalmente:
+
+```json
+{
+  "mcpServers": {
+    "balizas-v16": {
+      "command": "balizamcp"
+    }
+  }
+}
+```
+
+**Reinicia Claude Desktop** despues de modificar la configuracion.
+
+## Herramientas disponibles
+
+### `obtener_balizas_activas`
+
+Obtiene las balizas V16 actualmente activas en Espana.
+
+**Parametros** (todos opcionales):
+
+| Parametro | Tipo | Descripcion |
+|-----------|------|-------------|
+| `provincia` | string | Filtrar por provincia (ej: "Madrid", "Barcelona") |
+| `carretera` | string | Filtrar por carretera (ej: "A-1", "AP-7") |
+| `severidad` | string | Filtrar por severidad: "baja", "media", "alta", "critica" |
+| `limite` | number | Numero maximo de resultados |
+
+**Ejemplo de uso en Claude:**
+
+> "Cuantas balizas V16 hay activas en Madrid ahora mismo?"
+
+**Respuesta:**
+
+```json
+{
+  "fuente": "DGT - Punto de Acceso Nacional (NAP) - DATEX2",
+  "actualizadoEn": "2026-01-16T17:00:00.000Z",
+  "totalEncontradas": 33,
+  "totalEspana": 322,
+  "balizas": [
+    {
+      "id": "dgt-8355636",
+      "coordenadas": { "lat": 40.416775, "lon": -3.703790 },
+      "ubicacion": {
+        "nombreCarretera": "A-6",
+        "km": 15.2,
+        "municipio": "Las Rozas",
+        "provincia": "Madrid",
+        "comunidadAutonoma": "Madrid"
+      },
+      "incidente": {
+        "tipo": "vehiculo_detenido",
+        "severidad": "baja",
+        "horaInicio": "2026-01-16T16:45:00.000+01:00"
+      }
+    }
+  ]
+}
+```
+
+### `estadisticas_balizas`
+
+Obtiene estadisticas agregadas de las balizas V16 activas.
+
+**Ejemplo de uso en Claude:**
+
+> "Dame estadisticas de las balizas V16 activas en Espana"
+
+**Respuesta:**
+
+```json
+{
+  "estadisticas": {
+    "totalBalizasActivas": 322,
+    "porProvincia": {
+      "Madrid": 33,
+      "Valencia": 22,
+      "Alicante": 22,
+      "A Coruna": 20
+    },
+    "porSeveridad": {
+      "baja": 317,
+      "critica": 3,
+      "alta": 1,
+      "media": 1
+    }
+  }
+}
+```
+
+## Recurso MCP
+
+El servidor tambien expone un recurso MCP:
+
+- **URI**: `balizas://activas`
+- **Descripcion**: Listado completo de balizas V16 activas en formato JSON
+
+## Que son las balizas V16?
+
+Las **balizas V16** son dispositivos de senalizacion luminosa de emergencia que sustituyen a los triangulos de emergencia en Espana. Las balizas V16 **conectadas** (IoT) transmiten automaticamente su posicion GPS a la plataforma DGT 3.0 cuando se activan, permitiendo:
+
+- Alertar a otros conductores a traves de sistemas de navegacion
+- Mejorar la respuesta de servicios de emergencia
+- Reducir el riesgo de atropellos en carretera
+
+> Mas informacion: [balizame.com](https://balizame.com)
+
+## Fuente de datos
+
+Los datos provienen del **Punto de Acceso Nacional (NAP)** de la DGT en formato DATEX2:
+
+```
+https://nap.dgt.es/datex2/v3/dgt/SituationPublication/datex2_v36.xml
+```
+
+Este MCP filtra especificamente los incidentes de tipo `vehicleObstruction` y `obstruction`, que corresponden a vehiculos detenidos/averiados con baliza V16 activa.
+
+## Desarrollo
+
+```bash
+# Clonar repositorio
+git clone https://github.com/granero/balizamcp.git
+cd balizamcp
+
+# Instalar dependencias
+npm install
+
+# Desarrollo con hot-reload
+npm run dev
+
+# Compilar
+npm run build
+
+# Probar con MCP Inspector
+npx @modelcontextprotocol/inspector node dist/index.js
+```
+
+## Licencia
+
+[MIT](LICENSE) - Libre para uso personal y comercial.
+
+## Creditos
+
+- Datos: [DGT - Punto de Acceso Nacional](https://nap.dgt.es)
+- Inspiracion: [balizame.com](https://balizame.com)
+- Protocolo: [Model Context Protocol](https://modelcontextprotocol.io)
+
+---
+
+**Problemas o sugerencias?** [Abre un issue](https://github.com/granero/balizamcp/issues)

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+/**
+ * balizamcp - Datos en tiempo real de balizas V16 activas en España
+ *
+ * Servidor MCP oficial de balizame.com
+ * Obtiene información del Punto de Acceso Nacional (NAP) de la DGT
+ * filtrando incidentes de tipo vehicleObstruction (vehículos detenidos/averiados).
+ *
+ * @author granero
+ * @license MIT
+ * @see https://balizame.com
+ * @see https://github.com/granero/balizamcp
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,371 @@
+#!/usr/bin/env node
+/**
+ * balizamcp - Datos en tiempo real de balizas V16 activas en España
+ *
+ * Servidor MCP oficial de balizame.com
+ * Obtiene información del Punto de Acceso Nacional (NAP) de la DGT
+ * filtrando incidentes de tipo vehicleObstruction (vehículos detenidos/averiados).
+ *
+ * @author granero
+ * @license MIT
+ * @see https://balizame.com
+ * @see https://github.com/granero/balizamcp
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// ============= CONFIGURACIÓN =============
+const DGT_NAP_URL = "https://nap.dgt.es/datex2/v3/dgt/SituationPublication/datex2_v36.xml";
+const CACHE_TTL_MS = 60_000; // 1 minuto (frecuencia de actualización del NAP)
+const VERSION = "1.0.0";
+/**
+ * Causas DATEX2 que indican vehículo detenido/avería.
+ * Estos son los casos donde típicamente se activa una baliza V16.
+ * @see https://balizame.com para más información sobre balizas V16
+ */
+const VEHICLE_OBSTRUCTION_CAUSES = new Set(["vehicleObstruction", "obstruction"]);
+// ============= PARSING DATEX2 =============
+function extractCoordinates(xml) {
+    // Buscar latitud y longitud
+    const latMatch = xml.match(/<[^:]*:?latitude[^>]*>([^<]+)</i);
+    const lonMatch = xml.match(/<[^:]*:?longitude[^>]*>([^<]+)</i);
+    if (latMatch && lonMatch) {
+        const lat = parseFloat(latMatch[1].trim());
+        const lon = parseFloat(lonMatch[1].trim());
+        if (!isNaN(lat) && !isNaN(lon)) {
+            return { lat, lon };
+        }
+    }
+    return null;
+}
+function mapSeverity(severity) {
+    if (!severity)
+        return "baja";
+    const s = severity.toLowerCase();
+    if (s === "highest" || s === "critical")
+        return "crítica";
+    if (s === "high" || s === "severe")
+        return "alta";
+    if (s === "medium" || s === "moderate")
+        return "media";
+    return "baja";
+}
+function parseSituation(situationXml) {
+    // Extraer ID
+    const idMatch = situationXml.match(/id="([^"]+)"/);
+    if (!idMatch)
+        return null;
+    const id = idMatch[1];
+    // Extraer causa
+    const causeMatch = situationXml.match(/<[^:]*:?causeType[^>]*>([^<]+)</i);
+    const causa = causeMatch ? causeMatch[1].trim() : null;
+    // Solo procesar obstrucciones de vehículos (balizas V16)
+    if (!causa || !VEHICLE_OBSTRUCTION_CAUSES.has(causa)) {
+        return null;
+    }
+    // Extraer coordenadas
+    const coords = extractCoordinates(situationXml);
+    if (!coords)
+        return null;
+    // Extraer datos adicionales
+    const severityMatch = situationXml.match(/<[^:]*:?overallSeverity[^>]*>([^<]+)</i);
+    const roadMatch = situationXml.match(/<[^:]*:?roadNumber[^>]*>([^<]+)</i);
+    const roadNameMatch = situationXml.match(/<[^:]*:?roadName[^>]*>([^<]+)</i);
+    const kmMatch = situationXml.match(/<[^:]*:?kilometerPoint[^>]*>([^<]+)</i);
+    const directionMatch = situationXml.match(/<[^:]*:?tpegDirectionRoad[^>]*>([^<]+)</i);
+    const municipalityMatch = situationXml.match(/<[^:]*:?municipality[^>]*>([^<]+)</i);
+    const provinceMatch = situationXml.match(/<[^:]*:?province[^>]*>([^<]+)</i);
+    const autonomousCommunityMatch = situationXml.match(/<[^:]*:?autonomousCommunity[^>]*>([^<]+)</i);
+    const startTimeMatch = situationXml.match(/<[^:]*:?overallStartTime[^>]*>([^<]+)</i);
+    const lanesAffectedMatch = situationXml.match(/<[^:]*:?numberOfLanesRestricted[^>]*>([^<]+)</i);
+    const lanesTotalMatch = situationXml.match(/<[^:]*:?numberOfLanes[^>]*>([^<]+)</i);
+    const delayMatch = situationXml.match(/<[^:]*:?delayTimeValue[^>]*>([^<]+)</i);
+    const queueMatch = situationXml.match(/<[^:]*:?queueLengthValue[^>]*>([^<]+)</i);
+    const subtypeMatch = situationXml.match(/<[^:]*:?detailedCauseType[^>]*>[\s\S]*?<[^:>]+>([^<]+)</i);
+    // Extraer descripción del comentario
+    let descripcion;
+    const commentMatch = situationXml.match(/<[^:]*:?value[^>]*lang="es"[^>]*>([^<]+)</i) ||
+        situationXml.match(/<[^:]*:?value[^>]*>([^<]+)</i);
+    if (commentMatch) {
+        descripcion = commentMatch[1].trim().substring(0, 500);
+    }
+    return {
+        id: `dgt-${id}`,
+        lat: coords.lat,
+        lon: coords.lon,
+        carretera: roadMatch ? roadMatch[1].trim() : "",
+        nombreCarretera: roadNameMatch ? roadNameMatch[1].trim() : undefined,
+        kmInicio: kmMatch ? parseFloat(kmMatch[1]) : undefined,
+        direccion: directionMatch ? directionMatch[1].trim() : undefined,
+        municipio: municipalityMatch ? municipalityMatch[1].trim() : "",
+        provincia: provinceMatch ? provinceMatch[1].trim() : "",
+        comunidadAutonoma: autonomousCommunityMatch ? autonomousCommunityMatch[1].trim() : "",
+        descripcion,
+        severidad: mapSeverity(severityMatch ? severityMatch[1] : null),
+        tipoIncidente: "vehiculo_detenido",
+        subtipoIncidente: subtypeMatch ? subtypeMatch[1].trim() : undefined,
+        causa: causa,
+        horaInicio: startTimeMatch ? startTimeMatch[1].trim() : undefined,
+        carrilesAfectados: lanesAffectedMatch ? parseInt(lanesAffectedMatch[1]) : undefined,
+        carrilesTotales: lanesTotalMatch ? parseInt(lanesTotalMatch[1]) : undefined,
+        retrasoSegundos: delayMatch ? parseInt(delayMatch[1]) : undefined,
+        longitudColaMtrs: queueMatch ? parseInt(queueMatch[1]) : undefined,
+    };
+}
+function parseDatex2(xml) {
+    const balizas = [];
+    // Buscar todas las situaciones
+    const situationRegex = /<[^:]*:?situation\s+[^>]*id="[^"]+">[\s\S]*?<\/[^:]*:?situation>/gi;
+    let match;
+    while ((match = situationRegex.exec(xml)) !== null) {
+        const baliza = parseSituation(match[0]);
+        if (baliza) {
+            balizas.push(baliza);
+        }
+    }
+    return balizas;
+}
+// ============= CACHE Y DATOS =============
+let cachedData = null;
+let cacheTimestamp = 0;
+async function obtenerBalizasActivas() {
+    const now = Date.now();
+    // Usar caché si es válida (el NAP actualiza cada minuto)
+    if (cachedData && (now - cacheTimestamp) < CACHE_TTL_MS) {
+        return cachedData;
+    }
+    try {
+        const response = await fetch(DGT_NAP_URL, {
+            headers: {
+                "User-Agent": `balizamcp/${VERSION} (+https://balizame.com)`,
+                "Accept": "application/xml, text/xml, */*",
+                "Accept-Encoding": "gzip, deflate", // Solicitar compresión
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const xml = await response.text();
+        const balizas = parseDatex2(xml);
+        cachedData = {
+            timestamp: now,
+            total: balizas.length,
+            balizasActivas: balizas,
+            fuente: "DGT - Punto de Acceso Nacional (NAP) - DATEX2",
+            ultimaActualizacion: new Date().toISOString(),
+        };
+        cacheTimestamp = now;
+        return cachedData;
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : "Error desconocido";
+        console.error(`[MCP Balizas V16] Error obteniendo datos del NAP: ${errorMsg}`);
+        // Devolver caché antigua si existe, o datos vacíos
+        if (cachedData) {
+            return {
+                ...cachedData,
+                fuente: `DGT - NAP (caché: ${errorMsg})`,
+            };
+        }
+        return {
+            timestamp: now,
+            total: 0,
+            balizasActivas: [],
+            fuente: `DGT - NAP (error: ${errorMsg})`,
+            ultimaActualizacion: new Date().toISOString(),
+        };
+    }
+}
+// ============= SERVIDOR MCP =============
+const server = new Server({
+    name: "balizamcp",
+    version: VERSION,
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: "obtener_balizas_activas",
+                description: "Obtiene en TIEMPO REAL las balizas V16 actualmente activas en España. Devuelve las ubicaciones de vehículos detenidos/averiados que han activado su baliza V16 y están comunicando su posición a la DGT 3.0. Incluye coordenadas GPS, carretera, km, municipio, provincia y tiempo de activación.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        provincia: {
+                            type: "string",
+                            description: "Filtrar por provincia (ej: 'Madrid', 'Barcelona')",
+                        },
+                        carretera: {
+                            type: "string",
+                            description: "Filtrar por carretera (ej: 'A-1', 'AP-7')",
+                        },
+                        severidad: {
+                            type: "string",
+                            enum: ["baja", "media", "alta", "crítica"],
+                            description: "Filtrar por severidad del incidente",
+                        },
+                        limite: {
+                            type: "number",
+                            description: "Número máximo de resultados",
+                        },
+                    },
+                },
+            },
+            {
+                name: "estadisticas_balizas",
+                description: "Obtiene estadísticas de las balizas V16 activas: total por provincia, por carretera y distribución por severidad.",
+                inputSchema: {
+                    type: "object",
+                    properties: {},
+                },
+            },
+        ],
+    };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    if (name === "obtener_balizas_activas") {
+        const datos = await obtenerBalizasActivas();
+        let balizas = [...datos.balizasActivas];
+        // Aplicar filtros
+        if (args?.provincia) {
+            const busqueda = args.provincia.toLowerCase();
+            balizas = balizas.filter(b => b.provincia.toLowerCase().includes(busqueda));
+        }
+        if (args?.carretera) {
+            const busqueda = args.carretera.toLowerCase();
+            balizas = balizas.filter(b => b.carretera.toLowerCase().includes(busqueda));
+        }
+        if (args?.severidad) {
+            balizas = balizas.filter(b => b.severidad === args.severidad);
+        }
+        if (args?.limite && typeof args.limite === "number") {
+            balizas = balizas.slice(0, args.limite);
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        fuente: datos.fuente,
+                        actualizadoEn: datos.ultimaActualizacion,
+                        nota: "Datos en tiempo real de vehículos detenidos/averiados con baliza V16 activa comunicando a DGT 3.0",
+                        totalEncontradas: balizas.length,
+                        totalEspana: datos.total,
+                        balizas: balizas.map(b => ({
+                            id: b.id,
+                            coordenadas: { lat: b.lat, lon: b.lon },
+                            ubicacion: {
+                                carretera: b.carretera,
+                                nombreCarretera: b.nombreCarretera,
+                                km: b.kmInicio,
+                                direccion: b.direccion,
+                                municipio: b.municipio,
+                                provincia: b.provincia,
+                                comunidadAutonoma: b.comunidadAutonoma,
+                            },
+                            incidente: {
+                                tipo: b.tipoIncidente,
+                                subtipo: b.subtipoIncidente,
+                                severidad: b.severidad,
+                                descripcion: b.descripcion,
+                                horaInicio: b.horaInicio,
+                            },
+                            trafico: {
+                                carrilesAfectados: b.carrilesAfectados,
+                                carrilesTotales: b.carrilesTotales,
+                                retrasoSegundos: b.retrasoSegundos,
+                                longitudColaMtrs: b.longitudColaMtrs,
+                            },
+                        })),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    if (name === "estadisticas_balizas") {
+        const datos = await obtenerBalizasActivas();
+        // Contar por provincia
+        const porProvincia = {};
+        const porCarretera = {};
+        const porSeveridad = {};
+        for (const b of datos.balizasActivas) {
+            if (b.provincia) {
+                porProvincia[b.provincia] = (porProvincia[b.provincia] || 0) + 1;
+            }
+            if (b.carretera) {
+                porCarretera[b.carretera] = (porCarretera[b.carretera] || 0) + 1;
+            }
+            porSeveridad[b.severidad] = (porSeveridad[b.severidad] || 0) + 1;
+        }
+        // Ordenar por cantidad descendente
+        const ordenarDesc = (obj) => Object.entries(obj)
+            .sort((a, b) => b[1] - a[1])
+            .reduce((acc, [k, v]) => ({ ...acc, [k]: v }), {});
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        fuente: datos.fuente,
+                        actualizadoEn: datos.ultimaActualizacion,
+                        estadisticas: {
+                            totalBalizasActivas: datos.total,
+                            porProvincia: ordenarDesc(porProvincia),
+                            porCarretera: ordenarDesc(porCarretera),
+                            porSeveridad: ordenarDesc(porSeveridad),
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    return {
+        content: [{ type: "text", text: `Herramienta desconocida: ${name}` }],
+        isError: true,
+    };
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+        resources: [
+            {
+                uri: "balizas://activas",
+                name: "Balizas V16 activas en tiempo real",
+                description: "Listado de vehículos detenidos/averiados con baliza V16 activa comunicando a DGT 3.0",
+                mimeType: "application/json",
+            },
+        ],
+    };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === "balizas://activas") {
+        const datos = await obtenerBalizasActivas();
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "application/json",
+                    text: JSON.stringify({
+                        fuente: datos.fuente,
+                        actualizadoEn: datos.ultimaActualizacion,
+                        total: datos.total,
+                        balizas: datos.balizasActivas,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    throw new Error(`Recurso no encontrado: ${uri}`);
+});
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`balizamcp v${VERSION} - https://balizame.com`);
+    console.error("Datos en tiempo real de balizas V16 desde DGT NAP");
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "balizamcp",
+  "version": "1.0.0",
+  "description": "MCP Server oficial de balizame.com - Datos en tiempo real de balizas V16 activas en Espana via DGT NAP",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "balizamcp": "dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "balizas",
+    "v16",
+    "dgt",
+    "trafico",
+    "tiempo-real",
+    "espana",
+    "seguridad-vial",
+    "datex2",
+    "nap",
+    "claude",
+    "ai",
+    "balizame"
+  ],
+  "author": {
+    "name": "granero",
+    "url": "https://balizame.com"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/granero/balizamcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/granero/balizamcp/issues"
+  },
+  "homepage": "https://balizame.com"
+}