zerochat 8.3.0__tar.gz → 8.5.0__tar.gz

{zerochat-8.3.0/zerochat.egg-info → zerochat-8.5.0}/PKG-INFO

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

{zerochat-8.3.0 → zerochat-8.5.0}/pyproject.toml

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

{zerochat-8.3.0 → zerochat-8.5.0/zerochat.egg-info}/PKG-INFO

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

{zerochat-8.3.0 → zerochat-8.5.0}/zerochat.py

@@ -42,7 +42,7 @@ import webbrowser
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 
-SOURCE_BACKEND_VERSION = "8.3.0"
+SOURCE_BACKEND_VERSION = "8.5.0"
 
 def _read_source_version(filename: str) -> str | None:
     """Lee la versión de un archivo del repositorio cuando se ejecuta desde fuentes."""
@@ -388,6 +388,24 @@ 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`. Usa un `id` único en `service.json`, también cuando copies otro servicio.\\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. Si requiere una API key, declara la variable que exige el MCP en `launch.env` con el valor literal `PASTE_API_KEY_HERE`. No pidas la clave al usuario ni la escribas en el chat: indica la ruta absoluta del JSON y el campo que debe editar a mano. El usuario guardará su clave únicamente en el JSON local de su carpeta propia.\\n8. No instales ni 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 o API key. 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## Servicios remotos y claves API\\n\\nPara un remoto, lee también `service.json` e `installer.json` de la carpeta hermana `composio`. Crea una carpeta nueva con nombre e `id` propios; usa Composio como ejemplo del puente local, conservando `transport: \\\"stdio\\\"`. Consulta la documentación oficial del proveedor y de [mcp-remote](https://github.com/punkpeye/mcp-remote#custom-headers) para adaptar endpoint, transporte, cabeceras y autenticación. No copies sin verificar las opciones `--protocol`, los metadatos de cliente ni los parámetros OAuth específicos de Composio. Conserva `HOME` y `USERPROFILE` dentro de `${serviceDir}`.\\n\\nPara un MCP local que requiera una variable, deja este campo dentro de `launch`, conservando sus demás campos y usando el nombre de variable documentado por el MCP:\\n\\n```json\\n\\\"env\\\": {\\n  \\\"SERVICE_API_KEY\\\": \\\"PASTE_API_KEY_HERE\\\"\\n}\\n```\\n\\nPara un remoto que acepte `Authorization: Bearer`, los campos dentro de `launch` pueden ser:\\n\\n```json\\n\\\"args\\\": [\\n  \\\"${serviceDir}/node_modules/mcp-remote/dist/proxy.js\\\",\\n  \\\"https://mcp.example.com/mcp\\\",\\n  \\\"--header\\\",\\n  \\\"Authorization: Bearer ${REMOTE_API_KEY}\\\"\\n],\\n\\\"env\\\": {\\n  \\\"HOME\\\": \\\"${serviceDir}\\\",\\n  \\\"USERPROFILE\\\": \\\"${serviceDir}\\\",\\n  \\\"REMOTE_API_KEY\\\": \\\"PASTE_API_KEY_HERE\\\"\\n}\\n```\\n\\nAdapta la cabecera y su formato a lo que exige el proveedor. `remote.authentication` solo describe el servicio; no configura la autenticación. La referencia `${REMOTE_API_KEY}` en la cabecera la resuelve `mcp-remote`. ZeroChat no resuelve variables de entorno genéricas: en `launch.env`, `${SERVICE_API_KEY}` se pasaría como texto literal. Solo sustituye `${serviceDir}`, `${nodeExecutable}`, `${pythonExecutable}` y `${option:...}`. No pongas claves reales en argumentos ni en URLs.\\n\\n### Pasos para el usuario\\n\\n1. Usa una carpeta propia bajo el directorio de servicios, con nombre e `id` únicos. Si copias un servicio incluido, copia sus definiciones, no sus dependencias ni credenciales OAuth. No edites `ejemplo`, `composio`, `playwright` ni `memory`: sus archivos distribuidos se restauran al arrancar.\\n2. Abre el `service.json` de tu carpeta y sustituye `PASTE_API_KEY_HERE` por la clave real en `launch.env`. Mantén el JSON válido y los demás campos. No necesitas `export`, `.env` ni otro JSON de credenciales.\\n3. Restringe el archivo a tu usuario con `chmod 600 /ruta/absoluta/zerochat/services/mi-servicio/service.json` en Linux o Termux. La clave queda en texto plano: no compartas el archivo ni lo subas al repositorio o al chat.\\n4. Inicia el servicio desde Ajustes → MCP. Si la nueva carpeta no aparece, reinicia ZeroChat y conecta de nuevo. Para cambiar una clave, detén primero el servicio, edita el JSON y vuelve a iniciarlo.\\n5. ZeroChat conserva los servicios propios al reiniciar y actualizar. Borrar el directorio de datos elimina también esas claves: guarda una copia privada si la necesitas.\\n\\n## English: creating local and remote services\\n\\n1. Locate the user's absolute home directory and read `README.md`, `service.json` and `installer.json.example` in `zerochat/services/ejemplo`.\\n2. Read the requested MCP's official documentation. Create a sibling folder with its own name and unique JSON `id`; do not modify bundled definitions. Preserve bilingual text, `schemaVersion`, `transport: \\\"stdio\\\"`, `launch` and official `help` links.\\n3. For npm services, add `installer.json` with an exact package version and minimum Node.js major version. Otherwise use an existing executable or script.\\n4. For remote HTTP/SSE MCPs, also read the sibling `composio` JSON files and use its managed `mcp-remote` bridge as the example. Adapt endpoint, transport and authentication to the official provider and bridge documentation. Verify Composio-specific protocol and OAuth options before copying them. Keep `HOME` and `USERPROFILE` isolated inside `${serviceDir}`.\\n5. If an API key is required, put the literal `PASTE_API_KEY_HERE` under the required variable in `launch.env`. Do not request the user's key or place real secrets in chat, arguments or URLs. Give the absolute JSON path and exact field to edit. For remote header authentication, use `--header` with the provider's required header and a reference to the variable, as shown above; `mcp-remote` resolves that reference. `remote.authentication` is descriptive only.\\n6. Do not install or start the service. Report created files, official sources and outstanding requirements; the user will start it from Settings → MCP.\\n\\nThe user replaces `PASTE_API_KEY_HERE` directly in their own folder's JSON, preserves valid JSON and existing fields, and restricts the file with `chmod 600 /absolute/path/zerochat/services/my-service/service.json` on Linux/Termux. No shell export, `.env` or separate credentials JSON is needed. ZeroChat only expands service/interpreter paths and `${option:...}`, not generic environment placeholders in `launch.env`. The key is stored in plain text: do not share or commit the file or paste it into chat.\\n\\nIf a new folder does not appear, restart ZeroChat and reconnect. Stop an active service before editing its key, then start it again. User-created folders survive restarts and updates. Bundled definitions are restored on startup: copy them into a new folder and change the JSON `id` to customize them, without copying dependencies or OAuth credentials. Deleting the data directory also deletes custom services and their keys; keep a private backup if needed.\\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  \"scripts/xdg-open\": \"#!/data/data/com.termux/files/usr/bin/bash\\nexec \\\"${PREFIX:-/data/data/com.termux/files/usr}/bin/termux-open-url\\\" \\\"$@\\\"\\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")
+        if relative_path.startswith("scripts/"):
+            destination.chmod(0o755)
+# ==============================================================================
 # Herramientas Locales Core
 # ==============================================================================
 
@@ -1491,9 +1509,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
@@ -1504,6 +1524,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
 
 
@@ -1654,7 +1675,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()
 
@@ -1662,246 +1683,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):
-        example_dir = self.services_root / "ejemplo"
-        example_dir.mkdir(parents=True, exist_ok=True)
-        service_json_file = example_dir / "service.json"
-        example_server_file = example_dir / "ejemplo_mcp_server.py"
-        example_readme_file = example_dir / "README.md"
-        installer_example_file = example_dir / "installer.json.example"
-
-        if not service_json_file.exists():
-            service_json_file.write_text(json.dumps({
-                "schemaVersion": 1,
-                "id": "ejemplo",
-                "displayName": {
-                    "es": "Ejemplo de MCP",
-                    "en": "MCP example"
-                },
-                "description": {
-                    "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.",
-                    "en": "Minimal template for creating ZeroChat-managed MCP services. It demonstrates the stdio protocol and configuration structure for a new MCP."
-                },
-                "help": {
-                    "url": "help/mcp.html#crear-mcp-con-agente",
-                    "label": {
-                        "es": "Guía para crear un MCP gestionado",
-                        "en": "Guide to creating a managed MCP"
-                    }
-                },
-                "enabledByDefault": False,
-                "transport": "stdio",
-                "launch": {
-                    "executable": "${pythonExecutable}",
-                    "args": ["${serviceDir}/ejemplo_mcp_server.py"],
-                    "cwd": "${serviceDir}",
-                    "env": {},
-                    "handshakeTimeoutSeconds": 10
-                }
-            }, indent=2), encoding="utf-8")
-
-        if not example_server_file.exists():
-            example_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 MCP Example", "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")
-
-        if not installer_example_file.exists():
-            installer_example_file.write_text(json.dumps({
-                "schemaVersion": 1,
-                "type": "npm",
-                "product": {
-                    "package": "@scope/mcp-package",
-                    "version": "1.2.3"
-                },
-                "requirements": {
-                    "node": {"minimumMajor": 18}
-                }
-            }, indent=2) + "\n", encoding="utf-8")
-
-        if not example_readme_file.exists():
-            example_readme_file.write_text('''# Ejemplo de MCP gestionado\n\nEsta carpeta es la plantilla para que un agente cree un servicio MCP gestionado por ZeroChat. Para crear uno nuevo, copie esta estructura en `~/zerochat/services/<id-seguro>/`; no modifique este ejemplo.\n\n## Archivos\n\n- `service.json` es obligatorio. Define el identificador, los textos visibles, el proceso y el campo estándar opcional `help`.\n- `installer.json` es opcional. Créelo a partir de `installer.json.example` solo si ZeroChat debe instalar un paquete npm. Fije siempre una versión exacta.\n- El ejecutable o script de arranque se declara en `launch`. Use `${serviceDir}`, `${pythonExecutable}` o `${nodeExecutable}` en lugar de rutas de usuario.\n\n## Campo de ayuda\n\nTodos los servicios pueden incluir:\n\n```json\n"help": {\n  "url": "help/mcp.html",\n  "label": { "es": "Texto en español", "en": "English text" }\n}\n```\n\nLa interfaz muestra ese enlace en la tarjeta del servicio. `url` debe ser una ruta relativa de ZeroChat o una URL `https:` o `http:`.\n\n## Instrucción para un agente\n\nCopia este texto y sustituye solo `<nombre-del-mcp>`:\n\n```text\nSiguiendo estrictamente la estructura de ~/zerochat/services/ejemplo, busca en Internet la documentación oficial de instalación del MCP <nombre-del-mcp> y crea en ~/zerochat/services/ el directorio y los JSON necesarios para instalarlo y ejecutarlo en ZeroChat. Usa exclusivamente fuentes oficiales, fija versiones concretas, añade la sección help con el enlace a la documentación oficial, no incluyas secretos y no inicies el servicio. Al terminar, resume los archivos creados, las fuentes consultadas y los requisitos pendientes.\n```\n''', encoding="utf-8")
-
-        example_readme_file.write_text('''# Crear un MCP gestionado por ZeroChat
-
-Esta 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.
-
-## Procedimiento obligatorio
-
-1. Lee `README.md`, `service.json` y `installer.json.example` de la carpeta `ejemplo` situada en el directorio de datos de ZeroChat.
-2. Consulta solo la documentación oficial del MCP solicitado.
-3. Crea una carpeta con un identificador seguro y descriptivo junto a `ejemplo`.
-4. Crea `service.json` copiando esta estructura y adapta únicamente los valores necesarios.
-5. 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.
-6. Añade `help.url` con la página oficial de instalación y etiquetas en español e inglés.
-7. No incluyas tokens, contraseñas ni valores privados. Decláralos en `launch.env` con un marcador, por ejemplo `${HOME_ASSISTANT_TOKEN}`.
-8. No inicies el servicio. Al terminar, informa de los archivos creados, fuentes oficiales y requisitos pendientes.
-
-## Límites de ZeroChat
-
-ZeroChat 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`.
-
-No inventes una configuración para un MCP que requiera OAuth interactivo, transporte remoto HTTP/SSE, Docker, Python u otro instalador no soportado por estos JSON. En ese caso, no crees archivos: explica el requisito y qué soporte faltaría.
-
-## Contratos JSON
-
-- `service.json` es obligatorio. Conserva `schemaVersion`, `id`, textos bilingües, `transport: "stdio"` y `launch`.
-- En `launch`, usa `${serviceDir}`, `${nodeExecutable}` o `${pythonExecutable}`; no uses rutas absolutas de usuario.
-- `installer.json` es opcional y hoy solo admite `type: "npm"`.
-- `help` es opcional, pero debe incluirse en todo servicio creado:
-
-```json
-"help": {
-  "url": "https://documentacion-oficial.example/install",
-  "label": { "es": "Instalación oficial", "en": "Official installation" }
-}
-```
-
-## Prompt para el usuario
-
-Sustituye únicamente `<nombre-del-mcp>`:
-
-```text
-Para instalar el MCP <nombre-del-mcp>, localiza el directorio personal del usuario y lee primero el archivo zerochat/services/ejemplo/README.md usando su ruta absoluta. Sigue exactamente sus instrucciones.
-```
-''', 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()):
@@ -1948,6 +1729,7 @@ Para instalar el MCP <nombre-del-mcp>, localiza el directorio personal del usuar
                 "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,
@@ -2093,6 +1875,9 @@ Para instalar el MCP <nombre-del-mcp>, localiza el directorio personal del usuar
                 env = os.environ.copy()
                 for k, v in launch.get("env", {}).items():
                     env[k] = self._expand(v, values)
+                if is_termux_environment():
+                    scripts_dir = str(self.services_root / "scripts")
+                    env["PATH"] = scripts_dir + (os.pathsep + env["PATH"] if env.get("PATH") else "")
 
                 client = StdioMcpClient(
                     command, args, str(service_dir), env,
@@ -2412,7 +2197,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()
@@ -2737,21 +2525,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":
@@ -2793,7 +2566,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):