zerochat 8.1.0__tar.gz → 8.3.0__tar.gz

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

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

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

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

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

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

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

@@ -42,7 +42,7 @@ import webbrowser
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 
-SOURCE_BACKEND_VERSION = "8.1.0"
+SOURCE_BACKEND_VERSION = "8.3.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:
@@ -1488,8 +1499,16 @@ def public_tool_name(server_id: str, original: str) -> str:
     return name
 
 
+def _mcp_trace_text(value: object, max_len: int = 1000) -> str:
+    """Normaliza diagnósticos MCP para consola sin exponer secretos comunes."""
+    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)
+    return text[:max_len - 3] + "..." if len(text) > max_len else text
+
+
 class StdioMcpClient:
-    def __init__(self, command: str, args: list[str], cwd: str, env: dict[str, str]):
+    def __init__(self, command: str, args: list[str], cwd: str, env: dict[str, str], trace=None):
         self.command = command
         self.args = args
         self.cwd = cwd
@@ -1500,12 +1519,14 @@ class StdioMcpClient:
         self._lock = threading.Lock()
         self._alive = False
         self.tools: list[dict] = []
+        self._trace = trace or (lambda _message: None)
 
     def running(self) -> bool:
         return self._alive and self.process is not None and self.process.poll() is None
 
     def start(self, handshake_timeout: int = 30):
         cmd = [self.command] + self.args
+        self._trace(f"launching: {_mcp_trace_text(' '.join(cmd))}")
         self.process = subprocess.Popen(
             cmd,
             stdin=subprocess.PIPE,
@@ -1530,11 +1551,14 @@ class StdioMcpClient:
         self.notify("notifications/initialized")
         tools_resp = self.request("tools/list", {}, timeout=10)
         self.tools = tools_resp.get("tools", [])
+        self._trace(f"handshake completed; {len(self.tools)} tool(s) available")
 
     def _drain_stderr(self):
         if self.process and self.process.stderr:
-            for _ in self.process.stderr:
-                pass
+            for line in self.process.stderr:
+                line = _mcp_trace_text(line)
+                if line:
+                    self._trace(f"stderr: {line}")
 
     def _read_stdout(self):
         try:
@@ -1556,6 +1580,10 @@ class StdioMcpClient:
                         waiter.put(msg)
         finally:
             self._alive = False
+            if self.process:
+                return_code = self.process.poll()
+                if return_code is not None:
+                    self._trace(f"process exited with code {return_code}")
             with self._lock:
                 pending = list(self._pending.values())
                 self._pending.clear()
@@ -1618,11 +1646,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)
@@ -1634,37 +1658,50 @@ class McpServiceManager:
         self.services = self._load_services()
         self.preferences = self._load_preferences()
 
+    @staticmethod
+    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"
+        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": "dummy_mcp",
+                "id": "ejemplo",
                 "displayName": {
-                    "es": "MCP de prueba",
-                    "en": "Test MCP"
+                    "es": "Ejemplo de MCP",
+                    "en": "MCP example"
                 },
                 "description": {
-                    "es": "Servicio MCP mínimo para comprobar la infraestructura externa.",
-                    "en": "Minimal MCP service for verifying the external infrastructure."
+                    "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}/dummy_mcp_server.py"],
+                    "args": ["${serviceDir}/ejemplo_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
+        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):
@@ -1681,7 +1718,7 @@ for raw in sys.stdin:
     if method == "initialize":
         reply(req_id, {
             "protocolVersion": "2024-11-05",
-            "serverInfo": {"name": "ZeroChat Dummy MCP", "version": "1.0.0"},
+            "serverInfo": {"name": "ZeroChat MCP Example", "version": "1.0.0"},
             "capabilities": {"tools": {}}
         })
     elif method == "tools/list":
@@ -1705,6 +1742,66 @@ for raw in sys.stdin:
         })
 ''', 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)
@@ -1756,8 +1853,10 @@ for raw in sys.stdin:
                 "product": {
                     "package": "@playwright/mcp",
                     "version": "0.0.81",
-                    "browser": "chromium",
-                    "nodeMajor": 18
+                    "browser": "chromium"
+                },
+                "requirements": {
+                    "node": {"minimumMajor": 18}
                 }
             }, indent=2), encoding="utf-8")
 
@@ -1796,46 +1895,10 @@ for raw in sys.stdin:
                 "type": "npm",
                 "product": {
                     "package": "@modelcontextprotocol/server-memory",
-                    "version": "2026.8.31",
-                    "nodeMajor": 18
-                }
-            }, indent=2), encoding="utf-8")
-
-        # 4. lsp
-        lsp_dir = self.services_root / "lsp"
-        lsp_dir.mkdir(parents=True, exist_ok=True)
-        lsp_service = lsp_dir / "service.json"
-        lsp_installer = lsp_dir / "installer.json"
-        if not lsp_service.exists():
-            lsp_service.write_text(json.dumps({
-                "schemaVersion": 1,
-                "id": "lsp",
-                "displayName": {
-                    "es": "LSP y Navegación de Código",
-                    "en": "LSP & Code Intelligence"
-                },
-                "description": {
-                    "es": "Servidor de protocolos de lenguaje (LSP): salto a definiciones, búsqueda de símbolos, referencias e inspección de tipos sin sobrecargar el contexto.",
-                    "en": "Language Server Protocol (LSP) server: jump to definitions, symbol search, references, and type inspection without context overload."
+                    "version": "2026.8.31"
                 },
-                "enabledByDefault": False,
-                "transport": "stdio",
-                "launch": {
-                    "executable": "${nodeExecutable}",
-                    "args": ["${serviceDir}/node_modules/@axivo/mcp-lsp/dist/index.js"],
-                    "cwd": "${serviceDir}",
-                    "env": {},
-                    "handshakeTimeoutSeconds": 30
-                }
-            }, indent=2), encoding="utf-8")
-        if not lsp_installer.exists():
-            lsp_installer.write_text(json.dumps({
-                "schemaVersion": 1,
-                "type": "npm",
-                "product": {
-                    "package": "@axivo/mcp-lsp",
-                    "version": "1.0.5",
-                    "nodeMajor": 24
+                "requirements": {
+                    "node": {"minimumMajor": 18}
                 }
             }, indent=2), encoding="utf-8")
 
@@ -1884,6 +1947,7 @@ for raw in sys.stdin:
                 "id": server_id,
                 "displayName": server.get("displayName", {}),
                 "description": server.get("description", {}),
+                "help": server.get("help"),
                 "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,
@@ -1907,6 +1971,7 @@ for raw in sys.stdin:
         npm = shutil.which("npm") or "npm"
 
         if installer_file.exists():
+            self._trace(server_id, f"reading installer: {installer_file.name}")
             marker = service_dir / ".installed.json"
             try:
                 installer = json.loads(installer_file.read_text(encoding="utf-8"))
@@ -1922,16 +1987,24 @@ for raw in sys.stdin:
                 if not shutil.which("node") or not shutil.which("npm"):
                     raise RuntimeError("Node.js y npm son necesarios para instalar este servicio MCP")
 
-                required_node_major = int(product.get(
-                    "nodeMajor",
-                    24 if package == "@axivo/mcp-lsp" else 18
-                ))
+                requirements = installer.get("requirements", {})
+                node_requirement = requirements.get("node")
+                if node_requirement is None:
+                    # Compatibilidad con instaladores creados antes de requirements.node.
+                    required_node_major = int(product.get("nodeMajor", 18))
+                elif not isinstance(node_requirement, dict):
+                    raise RuntimeError("El requisito Node.js debe ser un objeto en installer.json")
+                else:
+                    required_node_major = node_requirement.get("minimumMajor")
+                    if not isinstance(required_node_major, int) or isinstance(required_node_major, bool) or required_node_major < 1:
+                        raise RuntimeError("El requisito Node.js debe definir minimumMajor como un entero positivo")
                 version_result = subprocess.run(
                     [node, "--version"], capture_output=True, text=True, timeout=5
                 )
-                version_match = re.match(r"v(\\d+)", version_result.stdout.strip())
+                version_match = re.match(r"v(\d+)", version_result.stdout.strip())
                 if version_result.returncode != 0 or not version_match:
                     raise RuntimeError("No se pudo comprobar la versión de Node.js necesaria para este servicio MCP")
+                self._trace(server_id, f"Node.js detected: {version_result.stdout.strip()} (minimum {required_node_major})")
                 if int(version_match.group(1)) < required_node_major:
                     raise RuntimeError(
                         f"{server_id} requiere Node.js {required_node_major}+; se detectó {version_result.stdout.strip()}"
@@ -1949,11 +2022,13 @@ for raw in sys.stdin:
 
                 if needs_install:
                     self.states[server_id] = "installing"
+                    self._trace(server_id, f"installing npm package: {package}@{version}")
                     manifest = service_dir / "package.json"
                     manifest.write_text(json.dumps({"private": True, "dependencies": {package: version}}, indent=2), encoding="utf-8")
                     res = subprocess.run([npm, "install", "--ignore-scripts", "--no-audit", "--no-fund"], cwd=service_dir, capture_output=True, text=True, timeout=600)
                     if res.returncode != 0:
                         raise RuntimeError(f"Fallo instalando dependencias npm: {res.stderr or res.stdout}")
+                    self._trace(server_id, f"npm package installed: {package}@{version}")
                     installation = {"type": "npm", "package": package, "version": version, "nodeExecutable": node}
                     browser = product.get("browser")
                     if browser:
@@ -1971,6 +2046,8 @@ for raw in sys.stdin:
                             )
                         installation["browser"] = browser
                     marker.write_text(json.dumps(installation, indent=2), encoding="utf-8")
+                else:
+                    self._trace(server_id, f"npm package already installed: {package}@{version}")
 
         return {
             "serviceDir": str(service_dir),
@@ -1988,6 +2065,8 @@ for raw in sys.stdin:
             if current and current.running():
                 return self.list_servers()
             self.states[server_id] = "starting"
+            client = None
+            self._trace(server_id, "start requested")
             try:
                 service_dir = server["_directory"]
                 values = self._prepare_service(server_id, server)
@@ -2015,7 +2094,10 @@ for raw in sys.stdin:
                 for k, v in launch.get("env", {}).items():
                     env[k] = self._expand(v, values)
 
-                client = StdioMcpClient(command, args, str(service_dir), env)
+                client = StdioMcpClient(
+                    command, args, str(service_dir), env,
+                    trace=lambda message: self._trace(server_id, message)
+                )
                 client.start(int(launch.get("handshakeTimeoutSeconds", 15)))
                 self.clients[server_id] = client
                 self.states[server_id] = "running"
@@ -2023,11 +2105,15 @@ for raw in sys.stdin:
                 entry = self.preferences.setdefault(server_id, {})
                 entry["enabled"] = True
                 self._save_preferences()
+                self._trace(server_id, "started successfully")
             except Exception as exc:
                 self.states[server_id] = "error"
                 self.errors[server_id] = str(exc)
+                self._trace(server_id, f"start failed: {exc}")
                 if server_id in self.clients:
                     self.clients.pop(server_id).stop()
+                elif client:
+                    client.stop()
             return self.list_servers()
 
     def stop(self, server_id: str) -> list[dict]: