zerochat 8.2.0__tar.gz → 8.4.0__tar.gz

{zerochat-8.2.0/zerochat.egg-info → zerochat-8.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zerochat
-Version: 8.2.0
+Version: 8.4.0
 Summary: Private local web client for AI models, tools and MCP services
 Author: Alberto Alday
 License-Expression: MIT

{zerochat-8.2.0 → zerochat-8.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zerochat"
-version = "8.2.0"
+version = "8.4.0"
 description = "Private local web client for AI models, tools and MCP services"
 readme = "README.md"
 requires-python = ">=3.10"

{zerochat-8.2.0 → zerochat-8.4.0/zerochat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zerochat
-Version: 8.2.0
+Version: 8.4.0
 Summary: Private local web client for AI models, tools and MCP services
 Author: Alberto Alday
 License-Expression: MIT

{zerochat-8.2.0 → zerochat-8.4.0}/zerochat.py

@@ -42,7 +42,7 @@ import webbrowser
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 
-SOURCE_BACKEND_VERSION = "8.2.0"
+SOURCE_BACKEND_VERSION = "8.4.0"
 
 def _read_source_version(filename: str) -> str | None:
     """Lee la versión de un archivo del repositorio cuando se ejecuta desde fuentes."""
@@ -93,9 +93,11 @@ UI_VERSION = _read_ui_version()
 DEFAULT_PORT = 6388
 DEFAULT_HOST = "127.0.0.1"
 DEFAULT_UI_URL = "https://albalday.github.io/zerochat/zerochat.html"
-REMOTE_VERSION_URL = "https://raw.githubusercontent.com/albalday/zerochat/master/package.json"
-PYPI_VERSION_URL = "https://pypi.org/pypi/zerochat/json"
 REMOTE_SCRIPT_URL = "https://raw.githubusercontent.com/albalday/zerochat/master/zerochat.py"
+# Las versiones remotas se consultan en las dos distribuciones que consume el
+# usuario: la interfaz publicada en GitHub Pages y el ejecutable en GitHub.
+REMOTE_UI_VERSION_URL = DEFAULT_UI_URL
+REMOTE_BACKEND_VERSION_URL = REMOTE_SCRIPT_URL
 CONSOLE_STATUS_IDLE_SECONDS = 8.0
 CONSOLE_CONTROL = None
 NOTICES: list[str] = []
@@ -335,22 +337,24 @@ def parse_version(ver: str) -> tuple[int, ...]:
     return tuple(parts)
 
 
-def _read_remote_version(url: str) -> str | None:
-    """Obtiene una versión publicada desde package.json o la API JSON de PyPI."""
+def _read_remote_content(url: str) -> str:
+    """Lee una cabecera acotada de un recurso publicado de ZeroChat."""
     req = urllib.request.Request(url, headers={"User-Agent": f"ZeroChat/{VERSION}"})
     with urllib.request.urlopen(req, timeout=3) as resp:
-        content = resp.read(4096).decode("utf-8", errors="ignore")
-    try:
-        data = json.loads(content)
-        if isinstance(data, dict):
-            candidate = data.get("version")
-            if not isinstance(candidate, str) and isinstance(data.get("info"), dict):
-                candidate = data["info"].get("version")
-            if isinstance(candidate, str):
-                return candidate.strip()
-    except (json.JSONDecodeError, TypeError):
-        pass
-    match = re.search(r'["\']?version["\']?\s*[:=]\s*["\'](\d+\.\d+\.\d+)["\']', content)
+        return resp.read(4096).decode("utf-8", errors="ignore")
+
+
+def _read_remote_ui_version() -> str | None:
+    """Extrae la versión del título de la interfaz servida por GitHub Pages."""
+    content = _read_remote_content(REMOTE_UI_VERSION_URL)
+    match = re.search(r"<title>\s*ZeroChat\s+v(\d+\.\d+\.\d+)\s*</title>", content, re.IGNORECASE)
+    return match.group(1) if match else None
+
+
+def _read_remote_backend_version() -> str | None:
+    """Extrae la versión estática del ejecutable publicado en GitHub."""
+    content = _read_remote_content(REMOTE_BACKEND_VERSION_URL)
+    match = re.search(r'^SOURCE_BACKEND_VERSION\s*=\s*["\'](\d+\.\d+\.\d+)["\']', content, re.MULTILINE)
     return match.group(1) if match else None
 
 
@@ -360,14 +364,21 @@ def has_new_backend_version(remote_version: str, local_version: str = VERSION) -
 
 
 def check_version():
-    """Informa de actualizaciones del backend, sin avisar por parches web."""
+    """Informa de la versión de Pages y de actualizaciones del ejecutable."""
     if get_dev_root() is not None:
         return
     try:
         installed = is_installed_runtime()
-        remote_ver = _read_remote_version(PYPI_VERSION_URL if installed else REMOTE_VERSION_URL)
-        if remote_ver and re.match(r"^\d+(\.\d+)+", remote_ver) and has_new_backend_version(remote_ver):
-            notice = f"Nueva versión del servidor disponible (local: {VERSION}, remota: {compatibility_version(remote_ver)})."
+        remote_ui_version = _read_remote_ui_version()
+        if remote_ui_version:
+            notice = f"Interfaz web en GitHub Pages: v{remote_ui_version}."
+            if remote_ui_version != UI_VERSION:
+                notice += f" El ejecutable incluye la referencia v{UI_VERSION}; la interfaz remota se cargará al abrir el navegador."
+            add_notice(notice)
+
+        remote_backend_version = _read_remote_backend_version()
+        if remote_backend_version and has_new_backend_version(remote_backend_version):
+            notice = f"Nueva versión del servidor disponible (local: {VERSION}, remota: {compatibility_version(remote_backend_version)})."
             if installed:
                 notice += f" Actualiza cuando quieras con: {sys.executable} -m pip install --upgrade --no-cache-dir zerochat"
             else:
@@ -377,6 +388,22 @@ def check_version():
         # Modo offline o timeout ignorado de forma segura
         pass
 # ==============================================================================
+# Generated from services/ by scripts/build-managed-services.mjs. Do not edit.
+# ==============================================================================
+
+import json
+
+MANAGED_SERVICE_FILES: dict[str, str] = json.loads("{\n  \"composio/installer.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"type\\\": \\\"npm\\\",\\n  \\\"product\\\": {\\n    \\\"package\\\": \\\"mcp-remote\\\",\\n    \\\"version\\\": \\\"0.13.5\\\"\\n  },\\n  \\\"requirements\\\": {\\n    \\\"node\\\": {\\n      \\\"minimumMajor\\\": 18\\n    }\\n  }\\n}\\n\",\n  \"composio/service.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"id\\\": \\\"composio\\\",\\n  \\\"displayName\\\": {\\n    \\\"es\\\": \\\"Composio Connect\\\",\\n    \\\"en\\\": \\\"Composio Connect\\\"\\n  },\\n  \\\"description\\\": {\\n    \\\"es\\\": \\\"MCP remoto para acceder a aplicaciones como Gmail, Google Drive, Slack o GitHub. Composio solicita la autorización de cada aplicación cuando sea necesaria.\\\",\\n    \\\"en\\\": \\\"Remote MCP for apps such as Gmail, Google Drive, Slack, and GitHub. Composio requests authorization for each app when it is needed.\\\"\\n  },\\n  \\\"help\\\": {\\n    \\\"url\\\": \\\"https://docs.composio.dev/docs/composio-connect\\\",\\n    \\\"label\\\": {\\n      \\\"es\\\": \\\"Guía oficial de Composio Connect\\\",\\n      \\\"en\\\": \\\"Composio Connect official guide\\\"\\n    }\\n  },\\n  \\\"enabledByDefault\\\": false,\\n  \\\"transport\\\": \\\"stdio\\\",\\n  \\\"remote\\\": {\\n    \\\"type\\\": \\\"mcp-remote\\\",\\n    \\\"transport\\\": \\\"streamable-http\\\",\\n    \\\"url\\\": \\\"https://connect.composio.dev/mcp\\\",\\n    \\\"authentication\\\": \\\"composio-connect\\\"\\n  },\\n  \\\"launch\\\": {\\n    \\\"executable\\\": \\\"${nodeExecutable}\\\",\\n    \\\"args\\\": [\\n      \\\"${serviceDir}/node_modules/mcp-remote/dist/proxy.js\\\",\\n      \\\"https://connect.composio.dev/mcp\\\",\\n      \\\"--protocol\\\",\\n      \\\"legacy\\\",\\n      \\\"--static-oauth-client-metadata\\\",\\n      \\\"{\\\\\\\"client_name\\\\\\\":\\\\\\\"zerochat-mcp-remote\\\\\\\"}\\\",\\n      \\\"--auth-timeout\\\",\\n      \\\"120\\\"\\n    ],\\n    \\\"cwd\\\": \\\"${serviceDir}\\\",\\n    \\\"env\\\": {\\n      \\\"HOME\\\": \\\"${serviceDir}\\\",\\n      \\\"USERPROFILE\\\": \\\"${serviceDir}\\\"\\n    },\\n    \\\"handshakeTimeoutSeconds\\\": 150\\n  }\\n}\\n\",\n  \"ejemplo/ejemplo_mcp_server.py\": \"#!/usr/bin/env python3\\nimport json\\nimport sys\\n\\ndef reply(req_id, result=None, error=None):\\n    resp = {\\\"jsonrpc\\\": \\\"2.0\\\", \\\"id\\\": req_id}\\n    if error:\\n        resp[\\\"error\\\"] = error\\n    else:\\n        resp[\\\"result\\\"] = result\\n    sys.stdout.write(json.dumps(resp) + \\\"\\\\n\\\")\\n    sys.stdout.flush()\\n\\nfor raw in sys.stdin:\\n    try:\\n        req = json.loads(raw)\\n    except Exception:\\n        continue\\n    req_id = req.get(\\\"id\\\")\\n    method = req.get(\\\"method\\\")\\n    params = req.get(\\\"params\\\", {})\\n    if method == \\\"initialize\\\":\\n        reply(req_id, {\\n            \\\"protocolVersion\\\": \\\"2024-11-05\\\",\\n            \\\"serverInfo\\\": {\\\"name\\\": \\\"ZeroChat MCP Example\\\", \\\"version\\\": \\\"1.0.0\\\"},\\n            \\\"capabilities\\\": {\\\"tools\\\": {}}\\n        })\\n    elif method == \\\"tools/list\\\":\\n        reply(req_id, {\\\"tools\\\": [{\\n            \\\"name\\\": \\\"echo\\\",\\n            \\\"description\\\": \\\"Echo back a message for testing.\\\",\\n            \\\"inputSchema\\\": {\\n                \\\"type\\\": \\\"object\\\",\\n                \\\"properties\\\": {\\\"message\\\": {\\\"type\\\": \\\"string\\\", \\\"description\\\": \\\"Message to echo.\\\"}},\\n                \\\"required\\\": [\\\"message\\\"]\\n            }\\n        }]})\\n    elif method == \\\"tools/call\\\":\\n        if params.get(\\\"name\\\") != \\\"echo\\\":\\n            reply(req_id, error={\\\"code\\\": -32601, \\\"message\\\": \\\"Tool not found\\\"})\\n            continue\\n        msg = params.get(\\\"arguments\\\", {}).get(\\\"message\\\", \\\"\\\")\\n        reply(req_id, {\\n            \\\"content\\\": [{\\\"type\\\": \\\"text\\\", \\\"text\\\": f\\\"echo: {msg}\\\"}],\\n            \\\"isError\\\": False\\n        })\\n\",\n  \"ejemplo/installer.json.example\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"type\\\": \\\"npm\\\",\\n  \\\"product\\\": {\\n    \\\"package\\\": \\\"@scope/mcp-package\\\",\\n    \\\"version\\\": \\\"1.2.3\\\"\\n  },\\n  \\\"requirements\\\": {\\n    \\\"node\\\": {\\n      \\\"minimumMajor\\\": 18\\n    }\\n  }\\n}\\n\",\n  \"ejemplo/README.md\": \"# Crear un MCP gestionado por ZeroChat\\n\\nEsta carpeta es la referencia para crear servicios MCP gestionados. La ubicación de producción es el directorio personal del usuario, seguido de `zerochat/services` (por ejemplo, `/home/usuario/zerochat/services`). No uses `~`, `$HOME` ni una ruta relativa como `services/`: primero identifica la ruta absoluta del directorio personal y úsala para localizar este archivo. El nuevo servicio se crea como carpeta hermana de `ejemplo`, nunca dentro de ella.\\n\\n## Procedimiento obligatorio\\n\\n1. Lee `README.md`, `service.json` y `installer.json.example` de la carpeta `ejemplo` situada en el directorio de datos de ZeroChat.\\n2. Consulta solo la documentación oficial del MCP solicitado.\\n3. Crea una carpeta con un identificador seguro y descriptivo junto a `ejemplo`.\\n4. Crea `service.json` copiando esta estructura y adapta únicamente los valores necesarios.\\n5. Crea `installer.json` solo si el MCP se distribuye como paquete npm. Copia `installer.json.example`, fija la versión exacta y declara la versión mínima de Node.js.\\n6. Añade `help.url` con la página oficial de instalación y etiquetas en español e inglés.\\n7. No incluyas tokens, contraseñas ni valores privados. Decláralos en `launch.env` con un marcador, por ejemplo `${HOME_ASSISTANT_TOKEN}`.\\n8. No inicies el servicio. Al terminar, informa de los archivos creados, fuentes oficiales y requisitos pendientes.\\n\\n## Límites de ZeroChat\\n\\nZeroChat gestiona procesos MCP por `stdio`. Puede instalar paquetes npm mediante `installer.json` y arrancarlos con `${nodeExecutable}`. También puede arrancar un ejecutable o script ya disponible con `launch`.\\n\\nZeroChat también puede usar `mcp-remote` como puente para un MCP remoto HTTP/SSE con OAuth. Decláralo como un servicio `stdio`: el proceso local debe ser `mcp-remote`, mientras que `remote` describe el endpoint remoto para la interfaz. Conserva las credenciales y el almacén OAuth dentro de `${serviceDir}`.\\n\\n## Contratos JSON\\n\\n- `service.json` es obligatorio. Conserva `schemaVersion`, `id`, textos bilingües, `transport: \\\"stdio\\\"` y `launch`.\\n- En `launch`, usa `${serviceDir}`, `${nodeExecutable}` o `${pythonExecutable}`; no uses rutas absolutas de usuario.\\n- `installer.json` es opcional y hoy solo admite `type: \\\"npm\\\"`.\\n- `help` es opcional, pero debe incluirse en todo servicio creado:\\n\\n```json\\n\\\"help\\\": {\\n  \\\"url\\\": \\\"https://documentacion-oficial.example/install\\\",\\n  \\\"label\\\": { \\\"es\\\": \\\"Instalación oficial\\\", \\\"en\\\": \\\"Official installation\\\" }\\n}\\n```\\n\\n## Prompt para el usuario\\n\\nSustituye únicamente `<nombre-del-mcp>`:\\n\\n```text\\nPara instalar el MCP <nombre-del-mcp>, lee primero services/ejemplo/README.md y sigue exactamente sus instrucciones.\\n```\\n\",\n  \"ejemplo/service.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"id\\\": \\\"ejemplo\\\",\\n  \\\"displayName\\\": {\\n    \\\"es\\\": \\\"Ejemplo de MCP\\\",\\n    \\\"en\\\": \\\"MCP example\\\"\\n  },\\n  \\\"description\\\": {\\n    \\\"es\\\": \\\"Plantilla mínima para crear servicios MCP gestionados por ZeroChat. Muestra el protocolo stdio y la estructura de configuración que debe seguir un nuevo MCP.\\\",\\n    \\\"en\\\": \\\"Minimal template for creating ZeroChat-managed MCP services. It demonstrates the stdio protocol and configuration structure for a new MCP.\\\"\\n  },\\n  \\\"help\\\": {\\n    \\\"url\\\": \\\"help/mcp.html#crear-mcp-con-agente\\\",\\n    \\\"label\\\": {\\n      \\\"es\\\": \\\"Guía para crear un MCP gestionado\\\",\\n      \\\"en\\\": \\\"Guide to creating a managed MCP\\\"\\n    }\\n  },\\n  \\\"enabledByDefault\\\": false,\\n  \\\"transport\\\": \\\"stdio\\\",\\n  \\\"launch\\\": {\\n    \\\"executable\\\": \\\"${pythonExecutable}\\\",\\n    \\\"args\\\": [\\\"${serviceDir}/ejemplo_mcp_server.py\\\"],\\n    \\\"cwd\\\": \\\"${serviceDir}\\\",\\n    \\\"env\\\": {},\\n    \\\"handshakeTimeoutSeconds\\\": 10\\n  }\\n}\\n\",\n  \"memory/installer.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"type\\\": \\\"npm\\\",\\n  \\\"product\\\": {\\n    \\\"package\\\": \\\"@modelcontextprotocol/server-memory\\\",\\n    \\\"version\\\": \\\"2026.8.31\\\"\\n  },\\n  \\\"requirements\\\": {\\n    \\\"node\\\": {\\n      \\\"minimumMajor\\\": 18\\n    }\\n  }\\n}\\n\",\n  \"memory/service.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"id\\\": \\\"memory\\\",\\n  \\\"displayName\\\": {\\n    \\\"es\\\": \\\"Memoria y Grafos (Knowledge Graph)\\\",\\n    \\\"en\\\": \\\"Memory & Knowledge Graph\\\"\\n  },\\n  \\\"description\\\": {\\n    \\\"es\\\": \\\"Almacenamiento persistente de entidades, preferencias y contexto histórico estructurado en un grafo de conocimiento.\\\",\\n    \\\"en\\\": \\\"Persistent storage of entities, preferences, and historical context structured as a knowledge graph.\\\"\\n  },\\n  \\\"enabledByDefault\\\": false,\\n  \\\"transport\\\": \\\"stdio\\\",\\n  \\\"launch\\\": {\\n    \\\"executable\\\": \\\"${nodeExecutable}\\\",\\n    \\\"args\\\": [\\\"${serviceDir}/node_modules/@modelcontextprotocol/server-memory/dist/index.js\\\"],\\n    \\\"cwd\\\": \\\"${serviceDir}\\\",\\n    \\\"env\\\": {\\n      \\\"MEMORY_FILE_PATH\\\": \\\"${serviceDir}/memory.jsonl\\\"\\n    },\\n    \\\"handshakeTimeoutSeconds\\\": 30\\n  }\\n}\\n\\n\",\n  \"playwright/installer.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"type\\\": \\\"npm\\\",\\n  \\\"product\\\": {\\n    \\\"package\\\": \\\"@playwright/mcp\\\",\\n    \\\"version\\\": \\\"0.0.81\\\",\\n    \\\"browser\\\": \\\"chromium\\\"\\n  },\\n  \\\"requirements\\\": {\\n    \\\"node\\\": {\\n      \\\"minimumMajor\\\": 18\\n    }\\n  }\\n}\\n\",\n  \"playwright/service.json\": \"{\\n  \\\"schemaVersion\\\": 1,\\n  \\\"id\\\": \\\"playwright\\\",\\n  \\\"displayName\\\": {\\n    \\\"es\\\": \\\"Playwright MCP\\\",\\n    \\\"en\\\": \\\"Playwright MCP\\\"\\n  },\\n  \\\"description\\\": {\\n    \\\"es\\\": \\\"Automatización de navegador mediante el servidor MCP oficial de Playwright.\\\",\\n    \\\"en\\\": \\\"Browser automation through the official Playwright MCP server.\\\"\\n  },\\n  \\\"enabledByDefault\\\": false,\\n  \\\"transport\\\": \\\"stdio\\\",\\n  \\\"launch\\\": {\\n    \\\"executable\\\": \\\"${nodeExecutable}\\\",\\n    \\\"args\\\": [\\\"${serviceDir}/node_modules/@playwright/mcp/cli.js\\\", \\\"--browser=chromium\\\"],\\n    \\\"cwd\\\": \\\"${serviceDir}\\\",\\n    \\\"env\\\": {},\\n    \\\"handshakeTimeoutSeconds\\\": 30\\n  },\\n  \\\"options\\\": [\\n    {\\n      \\\"id\\\": \\\"headless\\\",\\n      \\\"type\\\": \\\"boolean\\\",\\n      \\\"label\\\": {\\n        \\\"es\\\": \\\"Navegación en segundo plano (Headless)\\\",\\n        \\\"en\\\": \\\"Headless background mode\\\"\\n      },\\n      \\\"description\\\": {\\n        \\\"es\\\": \\\"Desactívalo para ver la ventana del navegador durante la automatización\\\",\\n        \\\"en\\\": \\\"Disable to display the browser window during automation\\\"\\n      },\\n      \\\"default\\\": true,\\n      \\\"argsWhenTrue\\\": [\\\"--headless\\\"],\\n      \\\"argsWhenFalse\\\": []\\n    }\\n  ]\\n}\\n\\n\"\n}")
+
+
+def materialize_managed_services(services_root: Path | None = None) -> None:
+    """Installs the managed service files without deleting user data or services."""
+    root = Path(services_root) if services_root else get_data_dir() / "services"
+    for relative_path, content in MANAGED_SERVICE_FILES.items():
+        destination = root / relative_path
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        destination.write_text(content, encoding="utf-8")
+# ==============================================================================
 # Herramientas Locales Core
 # ==============================================================================
 
@@ -1480,9 +1507,11 @@ def public_tool_name(server_id: str, original: str) -> str:
     def encode(value: str, tool: bool = False) -> str:
         if not isinstance(value, str) or not value or len(value) > 256:
             raise ValueError("Componente de nombre MCP no válido")
-        return "".join(ch if ("a" <= ch <= "y" or "0" <= ch <= "9" or (tool and ch == "_"))
+        # MCP function names preserve ASCII case, which keeps remote tool
+        # names readable while still escaping unsupported characters.
+        return "".join(ch if ("a" <= ch <= "z" or "A" <= ch <= "Z" or "0" <= ch <= "9" or (tool and ch == "_"))
                        else f"z{ord(ch):x}z" for ch in value)
-    name = f"mcp_{encode(server_id)}_{encode(original, True)}"
+    name = f"{encode(server_id)}_{encode(original, True)}"
     if len(name) > 64:
         raise ValueError(f"El nombre público de la herramienta MCP excede 64 caracteres: {name}")
     return name
@@ -1493,6 +1522,7 @@ def _mcp_trace_text(value: object, max_len: int = 1000) -> str:
     text = " ".join(str(value).strip().splitlines())
     text = re.sub(r"(?i)(\b(?:api[_-]?key|token|secret|password)\b\s*[=:]\s*)\S+", r"\1***", text)
     text = re.sub(r"(?i)(--(?:api[_-]?key|token|secret|password)\s+)\S+", r"\1***", text)
+    text = re.sub(r"(?i)([?&](?:access_token|code|id_token|refresh_token|state)=)[^&\s]+", r"\1***", text)
     return text[:max_len - 3] + "..." if len(text) > max_len else text
 
 
@@ -1635,11 +1665,7 @@ class McpServiceManager:
         if services_root:
             self.services_root = Path(services_root)
         else:
-            candidates = [
-                Path.cwd() / "services",
-                get_data_dir() / "services"
-            ]
-            self.services_root = candidates[0] if get_dev_root() is not None and candidates[0].is_dir() else candidates[1]
+            self.services_root = get_data_dir() / "services"
         self.services_root.mkdir(parents=True, exist_ok=True)
         self.config_file = get_data_dir() / "config" / "services.json"
         self.config_file.parent.mkdir(parents=True, exist_ok=True)
@@ -1647,7 +1673,7 @@ class McpServiceManager:
         self.states: dict[str, str] = {}
         self.errors: dict[str, str] = {}
         self._lock = threading.Lock()
-        self._ensure_default_services()
+        materialize_managed_services(self.services_root)
         self.services = self._load_services()
         self.preferences = self._load_preferences()
 
@@ -1655,177 +1681,6 @@ class McpServiceManager:
     def _trace(server_id: str, message: str):
         console_log(f"[{time.strftime('%H:%M:%S')}] [MCP {server_id}] {_mcp_trace_text(message)}", flush=True)
 
-    def _ensure_default_services(self):
-        dummy_dir = self.services_root / "dummy_mcp"
-        dummy_dir.mkdir(parents=True, exist_ok=True)
-        service_json_file = dummy_dir / "service.json"
-        dummy_server_file = dummy_dir / "dummy_mcp_server.py"
-
-        if not service_json_file.exists():
-            service_json_file.write_text(json.dumps({
-                "schemaVersion": 1,
-                "id": "dummy_mcp",
-                "displayName": {
-                    "es": "MCP de prueba",
-                    "en": "Test MCP"
-                },
-                "description": {
-                    "es": "Servicio MCP mínimo para comprobar la infraestructura externa.",
-                    "en": "Minimal MCP service for verifying the external infrastructure."
-                },
-                "enabledByDefault": False,
-                "transport": "stdio",
-                "launch": {
-                    "executable": "${pythonExecutable}",
-                    "args": ["${serviceDir}/dummy_mcp_server.py"],
-                    "cwd": "${serviceDir}",
-                    "env": {},
-                    "handshakeTimeoutSeconds": 10
-                }
-            }, indent=2), encoding="utf-8")
-
-        if not dummy_server_file.exists():
-            dummy_server_file.write_text('''#!/usr/bin/env python3
-import json, sys
-
-def reply(req_id, result=None, error=None):
-    resp = {"jsonrpc": "2.0", "id": req_id}
-    if error: resp["error"] = error
-    else: resp["result"] = result
-    sys.stdout.write(json.dumps(resp) + "\\n")
-    sys.stdout.flush()
-
-for raw in sys.stdin:
-    try: req = json.loads(raw)
-    except: continue
-    req_id, method, params = req.get("id"), req.get("method"), req.get("params", {})
-    if method == "initialize":
-        reply(req_id, {
-            "protocolVersion": "2024-11-05",
-            "serverInfo": {"name": "ZeroChat Dummy MCP", "version": "1.0.0"},
-            "capabilities": {"tools": {}}
-        })
-    elif method == "tools/list":
-        reply(req_id, {"tools": [{
-            "name": "echo",
-            "description": "Echo back a message for testing.",
-            "inputSchema": {
-                "type": "object",
-                "properties": {"message": {"type": "string", "description": "Message to echo."}},
-                "required": ["message"]
-            }
-        }]})
-    elif method == "tools/call":
-        if params.get("name") != "echo":
-            reply(req_id, error={"code": -32601, "message": "Tool not found"})
-            continue
-        msg = params.get("arguments", {}).get("message", "")
-        reply(req_id, {
-            "content": [{"type": "text", "text": f"echo: {msg}"}],
-            "isError": False
-        })
-''', encoding="utf-8")
-
-        # 2. playwright
-        playwright_dir = self.services_root / "playwright"
-        playwright_dir.mkdir(parents=True, exist_ok=True)
-        pw_service = playwright_dir / "service.json"
-        pw_installer = playwright_dir / "installer.json"
-        if not pw_service.exists():
-            pw_service.write_text(json.dumps({
-                "schemaVersion": 1,
-                "id": "playwright",
-                "displayName": {
-                    "es": "Playwright MCP",
-                    "en": "Playwright MCP"
-                },
-                "description": {
-                    "es": "Automatización de navegador mediante el servidor MCP oficial de Playwright.",
-                    "en": "Browser automation through the official Playwright MCP server."
-                },
-                "enabledByDefault": False,
-                "transport": "stdio",
-                "launch": {
-                    "executable": "${nodeExecutable}",
-                    "args": ["${serviceDir}/node_modules/@playwright/mcp/cli.js", "--browser=chromium"],
-                    "cwd": "${serviceDir}",
-                    "env": {},
-                    "handshakeTimeoutSeconds": 30
-                },
-                "options": [
-                    {
-                        "id": "headless",
-                        "type": "boolean",
-                        "label": {
-                            "es": "Navegación en segundo plano (Headless)",
-                            "en": "Headless background mode"
-                        },
-                        "description": {
-                            "es": "Desactívalo para ver la ventana del navegador durante la automatización",
-                            "en": "Disable to display the browser window during automation"
-                        },
-                        "default": True,
-                        "argsWhenTrue": ["--headless"],
-                        "argsWhenFalse": []
-                    }
-                ]
-            }, indent=2), encoding="utf-8")
-        if not pw_installer.exists():
-            pw_installer.write_text(json.dumps({
-                "schemaVersion": 1,
-                "type": "npm",
-                "product": {
-                    "package": "@playwright/mcp",
-                    "version": "0.0.81",
-                    "browser": "chromium"
-                },
-                "requirements": {
-                    "node": {"minimumMajor": 18}
-                }
-            }, indent=2), encoding="utf-8")
-
-        # 3. memory
-        memory_dir = self.services_root / "memory"
-        memory_dir.mkdir(parents=True, exist_ok=True)
-        mem_service = memory_dir / "service.json"
-        mem_installer = memory_dir / "installer.json"
-        if not mem_service.exists():
-            mem_service.write_text(json.dumps({
-                "schemaVersion": 1,
-                "id": "memory",
-                "displayName": {
-                    "es": "Memoria y Grafos (Knowledge Graph)",
-                    "en": "Memory & Knowledge Graph"
-                },
-                "description": {
-                    "es": "Almacenamiento persistente de entidades, preferencias y contexto histórico estructurado en un grafo de conocimiento.",
-                    "en": "Persistent storage of entities, preferences, and historical context structured as a knowledge graph."
-                },
-                "enabledByDefault": False,
-                "transport": "stdio",
-                "launch": {
-                    "executable": "${nodeExecutable}",
-                    "args": ["${serviceDir}/node_modules/@modelcontextprotocol/server-memory/dist/index.js"],
-                    "cwd": "${serviceDir}",
-                    "env": {
-                        "MEMORY_FILE_PATH": "${serviceDir}/memory.jsonl"
-                    },
-                    "handshakeTimeoutSeconds": 30
-                }
-            }, indent=2), encoding="utf-8")
-        if not mem_installer.exists():
-            mem_installer.write_text(json.dumps({
-                "schemaVersion": 1,
-                "type": "npm",
-                "product": {
-                    "package": "@modelcontextprotocol/server-memory",
-                    "version": "2026.8.31"
-                },
-                "requirements": {
-                    "node": {"minimumMajor": 18}
-                }
-            }, indent=2), encoding="utf-8")
-
     def _load_services(self) -> dict[str, dict]:
         servers = {}
         for directory in sorted(self.services_root.iterdir()):
@@ -1871,6 +1726,8 @@ for raw in sys.stdin:
                 "id": server_id,
                 "displayName": server.get("displayName", {}),
                 "description": server.get("description", {}),
+                "help": server.get("help"),
+                "remote": server.get("remote"),
                 "enabled": pref.get("enabled", server.get("enabledByDefault", False)),
                 "status": "running" if running else self.states.get(server_id, "stopped"),
                 "toolCount": len(client.tools) if running else 0,
@@ -2335,7 +2192,10 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
         self.send_header("Content-Length", str(len(body)))
         self.send_cors_headers()
         self.end_headers()
-        self.wfile.write(body)
+        try:
+            self.wfile.write(body)
+        except (BrokenPipeError, ConnectionResetError):
+            self.close_connection = True
 
     def do_GET(self):
         t0 = time.monotonic()
@@ -2660,21 +2520,6 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
                             "content": [{"type": "text", "text": json.dumps({"success": False, "error": str(ex)}, ensure_ascii=False)}],
                             "isError": True
                         }
-                elif tool_name.startswith("mcp_"):
-                    try:
-                        result = GLOBAL_MCP_MANAGER.call(tool_name, tool_args)
-                        if isinstance(result, dict) and result.get("isError"):
-                            c_list = result.get("content", [])
-                            if c_list and isinstance(c_list, list) and isinstance(c_list[0], dict):
-                                tool_error_info = c_list[0].get("text", "Error en herramienta MCP")
-                            else:
-                                tool_error_info = "Error en herramienta MCP"
-                    except Exception as ex:
-                        tool_error_info = str(ex)
-                        result = {
-                            "content": [{"type": "text", "text": json.dumps({"success": False, "error": str(ex)}, ensure_ascii=False)}],
-                            "isError": True
-                        }
                 else:
                     error = {"code": -32601, "message": f"Herramienta local '{tool_name}' no encontrada."}
             elif method == "zerochat/external/status":
@@ -2716,7 +2561,11 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
         self.send_header("Content-Length", str(len(resp_bytes)))
         self.send_cors_headers()
         self.end_headers()
-        self.wfile.write(resp_bytes)
+        try:
+            self.wfile.write(resp_bytes)
+        except (BrokenPipeError, ConnectionResetError):
+            self.close_connection = True
+            return
         self._log_res(200, f"{safe_path} {action_tag}", (time.monotonic() - t0) * 1000, error_info=error_info)
 
     def log_message(self, format, *args):