zerochat 9.7.0__tar.gz → 9.9.0__tar.gz

{zerochat-9.7.0/zerochat.egg-info → zerochat-9.9.0}/PKG-INFO

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

{zerochat-9.7.0 → zerochat-9.9.0}/pyproject.toml

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

{zerochat-9.7.0 → zerochat-9.9.0/zerochat.egg-info}/PKG-INFO

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

{zerochat-9.7.0 → zerochat-9.9.0}/zerochat.py

@@ -46,7 +46,7 @@ import zlib
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 
-SOURCE_BACKEND_VERSION = "9.7.0"
+SOURCE_BACKEND_VERSION = "9.9.0"
 
 def _read_source_version(filename: str) -> str | None:
     """Lee la versión de un archivo del repositorio cuando se ejecuta desde fuentes."""
@@ -1344,6 +1344,92 @@ def set_project_directory(path) -> dict:
     return {"cwd": str(target), "previous_cwd": previous}
 
 
+# Visores gráficos que `git difftool` ya sabe lanzar, en orden de preferencia, con el ejecutable que los delata.
+GUI_DIFF_TOOLS = {"vscode": "code", "meld": "meld", "kdiff3": "kdiff3", "kompare": "kompare", "gvimdiff": "gvim"}
+# Respaldo cuando no hay ninguno: visor web que se instala en el entorno aislado de ZeroChat.
+WEBDIFF_REQUIREMENT = "webdiff==1.4.0"
+WEBDIFF_INSTALL_TIMEOUT_SECONDS = 120
+
+
+def _venv_webdiff() -> Path:
+    """Ruta de webdiff dentro de ~/zerochat/.venv, junto al intérprete del entorno."""
+    venv_python = get_venv_python(get_venv_dir())
+    return venv_python.with_name("webdiff" + venv_python.suffix)
+
+
+def _find_webdiff() -> str:
+    """webdiff del entorno de ZeroChat o, si no, del PATH; '' si no hay ninguno."""
+    venv_webdiff = _venv_webdiff()
+    if venv_webdiff.exists():
+        return str(venv_webdiff)
+    return shutil.which("webdiff") or ""
+
+
+def _diff_tool_settings(tool: str, webdiff_bin: str) -> list:
+    """Pares (clave, valor) de git config que deja `tool` como visor gráfico; webdiff no es un visor integrado de git."""
+    settings = [("diff.guitool", tool)]
+    if tool == "webdiff":
+        settings.insert(0, ("difftool.webdiff.cmd", f'"{webdiff_bin}" "$LOCAL" "$REMOTE"'))
+    return settings
+
+
+def detect_gui_diff_tool() -> dict:
+    """Visor que proponer cuando Git no tiene ninguno: el primero instalado o, si no hay, webdiff.
+
+    Incluye las órdenes exactas que aplicará configure_gui_diff_tool, para mostrarlas antes de confirmar.
+    """
+    tool = next((name for name, binary in GUI_DIFF_TOOLS.items() if shutil.which(binary)), "webdiff")
+    webdiff_bin = _find_webdiff()
+    return {
+        "tool": tool,
+        "install": tool == "webdiff" and not webdiff_bin,
+        "commands": [
+            shlex.join(["git", "config", "--global", key, value])
+            for key, value in _diff_tool_settings(tool, webdiff_bin or str(_venv_webdiff()))
+        ],
+    }
+
+
+def _install_webdiff() -> str:
+    """Instala webdiff en ~/zerochat/.venv y devuelve la ruta del ejecutable."""
+    ensure_virtual_environment()
+    venv_python = get_venv_python(get_venv_dir())
+    if not venv_python.exists():
+        raise RuntimeError(f"No se pudo preparar el entorno virtual de ZeroChat: falta {venv_python}")
+    res = subprocess.run(
+        [str(venv_python), "-m", "pip", "install", WEBDIFF_REQUIREMENT],
+        capture_output=True,
+        text=True,
+        timeout=WEBDIFF_INSTALL_TIMEOUT_SECONDS,
+        check=False
+    )
+    if res.returncode != 0:
+        raise RuntimeError(f"Error instalando webdiff: {(res.stderr or res.stdout).strip()[-500:]}")
+    webdiff = _venv_webdiff()
+    if not webdiff.exists():
+        raise RuntimeError(f"webdiff se instaló pero no aparece en {webdiff}")
+    return str(webdiff)
+
+
+def configure_gui_diff_tool(tool) -> dict:
+    """Deja `tool` como visor gráfico global de Git, instalando antes webdiff si es el elegido y falta."""
+    if not isinstance(tool, str) or (tool != "webdiff" and tool not in GUI_DIFF_TOOLS):
+        raise ValueError(f"Visor de diffs '{tool}' no reconocido.")
+    git_bin = shutil.which("git")
+    if not git_bin:
+        raise RuntimeError("Git no está instalado o no se encuentra en el PATH del sistema.")
+
+    webdiff_bin = ""
+    if tool == "webdiff":
+        webdiff_bin = _find_webdiff() or _install_webdiff()
+    elif not shutil.which(GUI_DIFF_TOOLS[tool]):
+        raise ValueError(f"'{GUI_DIFF_TOOLS[tool]}' no está en el PATH del sistema.")
+
+    for key, value in _diff_tool_settings(tool, webdiff_bin):
+        subprocess.run([git_bin, "config", "--global", key, value], capture_output=True, timeout=5, check=True)
+    return {"tool": tool}
+
+
 def _configured_gui_diff_tool(git_bin: str, repo_root: Path) -> str:
     """Herramienta gráfica que usaría `git difftool --gui`, o '' si no hay ninguna configurada.
 
@@ -1365,7 +1451,10 @@ def _configured_gui_diff_tool(git_bin: str, repo_root: Path) -> str:
 
 
 def open_file_diff(path: str, commit_fallback: bool = False) -> dict:
-    """Abre un visor externo de diffs (git difftool) para comparar el fichero actual frente a Git HEAD, su último commit o fichero vacío."""
+    """Abre un visor externo de diffs (git difftool) para comparar el fichero actual frente a Git HEAD, su último commit o fichero vacío.
+
+    Sin visor gráfico configurado no lanza nada y devuelve en `setup` el que propone configurar.
+    """
     if not isinstance(path, str) or not path.strip():
         raise ValueError("La ruta del archivo está vacía.")
     if len(path) > MAX_PATH_LENGTH:
@@ -1398,10 +1487,7 @@ def open_file_diff(path: str, commit_fallback: bool = False) -> dict:
 
     repo_root = Path(res.stdout.strip()).resolve()
     if not _configured_gui_diff_tool(git_bin, repo_root):
-        raise ValueError(
-            "No hay un visor gráfico de diffs configurado en Git. Configura uno, por ejemplo: "
-            "git config --global diff.guitool meld"
-        )
+        return {"success": False, "setup": detect_gui_diff_tool()}
 
     has_head = subprocess.run(
         [git_bin, "rev-parse", "--verify", "HEAD"],
@@ -1727,17 +1813,13 @@ class PersistentBrowserSession:
 const readline = require('readline');
 let playwright;
 try {
-  playwright = require('playwright');
-} catch (e1) {
-  try {
-    playwright = require(process.env.ZEROCHAT_PLAYWRIGHT_MODULE);
-  } catch (e2) {
-    console.log(JSON.stringify({
-      success: false,
-      error: "Playwright is not available. Install it with 'npm install playwright' or enable the Playwright MCP service."
-    }));
-    process.exit(1);
-  }
+  playwright = require(process.env.ZEROCHAT_PLAYWRIGHT_MODULE);
+} catch (e) {
+  console.log(JSON.stringify({
+    success: false,
+    error: "Playwright is not available. Start the Playwright service once in Settings > MCP to install it."
+  }));
+  process.exit(1);
 }
 
 (async () => {
@@ -1903,8 +1985,8 @@ def browser_action_availability() -> dict:
     """Comprueba requisitos locales sin lanzar Node.js ni Chromium."""
     if not shutil.which("node"):
         return {"available": False, "error": "Node.js is not installed or not found in system PATH."}
-    playwright_locations = (Path.cwd() / "node_modules" / "playwright", playwright_service_module())
-    if not any(location.is_dir() for location in playwright_locations):
+    # Solo el Playwright del servicio, no el node_modules de la carpeta desde la que arranca el servidor.
+    if not playwright_service_cli().is_file():
         return {"available": False, "error": "Playwright is not available."}
     # El runner prueba las entradas de Chromium de Playwright y los canales chrome y msedge.
     browsers = system_browsers()
@@ -1913,6 +1995,11 @@ def browser_action_availability() -> dict:
     return {"available": False, "error": "Playwright Chromium is not installed."}
 
 
+def playwright_status() -> dict:
+    """Playwright del servicio y browser_action tal como están ahora, para el latido del cliente."""
+    return {"installed": playwright_service_cli().is_file(), "browserAction": browser_action_availability()}
+
+
 def browser_action(action: str, url: str | None = None, selector: str | None = None, value: str | None = None) -> str:
     """Control a headless browser for UI testing and visual inspection."""
     try:
@@ -2217,18 +2304,22 @@ def playwright_launch_env(config: dict) -> dict[str, str]:
 
 
 def validate_profile_browser(raw) -> dict:
-    """Navegador que exige un perfil: el propio con un motor o el del usuario con uno de sus navegadores."""
-    if isinstance(raw, dict) and raw.get("mode") == "own" and set(raw) == {"mode", "engine"} and raw["engine"] in OWN_BROWSER_ENGINES:
-        return {"mode": "own", "engine": raw["engine"]}
+    """Navegador que exige un perfil: el propio con un motor, y headless False si exige la ventana
+    visible, o el del usuario con uno de sus navegadores."""
+    if isinstance(raw, dict) and raw.get("mode") == "own" and raw.get("engine") in OWN_BROWSER_ENGINES:
+        if set(raw) == {"mode", "engine"}:
+            return {"mode": "own", "engine": raw["engine"]}
+        if set(raw) == {"mode", "engine", "headless"} and raw["headless"] is False:
+            return {"mode": "own", "engine": raw["engine"], "headless": False}
     if isinstance(raw, dict) and raw.get("mode") == "user" and set(raw) == {"mode", "userBrowser"} and raw["userBrowser"] in USER_BROWSERS:
         return {"mode": "user", "userBrowser": raw["userBrowser"]}
-    raise ValueError("browser debe ser {mode: own, engine} o {mode: user, userBrowser} con un motor o navegador admitido")
+    raise ValueError("browser debe ser {mode: own, engine[, headless: false]} o {mode: user, userBrowser} con un motor o navegador admitido")
 
 
 def browser_choice(config: dict) -> dict:
     """Modo y navegador con los que arranca Playwright MCP, en la forma de validate_profile_browser."""
     if config["mode"] == "own":
-        return {"mode": "own", "engine": config["engine"]}
+        return {"mode": "own", "engine": config["engine"], **({} if config["headless"] else {"headless": False})}
     return {"mode": "user", "userBrowser": config["userBrowser"]}
 
 
@@ -2358,22 +2449,19 @@ class BrowserEngines:
         return {name: (title, Path(location.strip())) for title, name, location in _DRY_RUN_ENTRY.findall(result.stdout)}
 
     def list(self) -> dict:
+        """Navegadores del sistema y motores de Playwright; sin Playwright del servicio no hay motores."""
         cli = playwright_service_cli()
         result = {"systemBrowsers": system_browsers(), "extensions": user_browser_extensions(), "engines": []}
         if not cli.is_file():
-            return {**result, "available": False, "error": "Playwright MCP is not installed."}
-        try:
-            version = json.loads((cli.parent / "package.json").read_text(encoding="utf-8")).get("version")
-            locations = self._locations(cli)
-        except (OSError, json.JSONDecodeError, RuntimeError, subprocess.SubprocessError) as err:
-            return {**result, "available": False, "error": str(err)}
+            return result
+        locations = self._locations(cli)
         with self._lock:
             jobs = {engine: dict(job) for engine, job in self._jobs.items()}
         for engine, entries in ENGINE_CACHE_ENTRIES.items():
             title = locations.get(entries[0], (engine,))[0]
             installed = all(name in locations and (locations[name][1] / "INSTALLATION_COMPLETE").is_file() for name in entries)
             result["engines"].append({"id": engine, "title": title, "installed": installed, **jobs.get(engine, {})})
-        return {**result, "available": True, "playwrightVersion": version}
+        return result
 
     def _check_engine(self, engine) -> Path:
         if engine not in ENGINE_CACHE_ENTRIES:
@@ -2864,6 +2952,12 @@ class McpServiceManager:
             client = self.clients.get(server_id)
             state = self.states.get(server_id, "stopped")
             running = bool(client and client.running() and state == "running")
+            error = self.errors.get(server_id)
+            # El proceso de un servicio en marcha puede morir sin que nadie lo detenga.
+            if state == "running" and client and not running:
+                code = client.process.poll() if client.process else None
+                state = "error"
+                error = f"MCP process exited with code {code}" if code is not None else "MCP process is not responding"
             pref = self.preferences.get(server_id, {})
             result.append({
                 "id": server_id,
@@ -2874,7 +2968,7 @@ class McpServiceManager:
                 "enabled": pref.get("enabled", server.get("enabledByDefault", False)),
                 "status": "running" if running else state,
                 "toolCount": len(client.tools) if running else 0,
-                "error": self.errors.get(server_id),
+                "error": error,
                 "options": server.get("options", []),
                 "userOptions": pref.get("options", {}),
                 "oauthUrl": client.oauth_url if client else None,
@@ -3568,12 +3662,16 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
         if is_heartbeat:
             mark_browser_active()
             # cwd permite a cada pestaña notar que otra ha cambiado el directorio del proyecto;
-            # jobs, mostrar los comandos que siguen en marcha y avisar antes de cerrar si se detendrían.
+            # jobs, mostrar los comandos que siguen en marcha y avisar antes de cerrar si se detendrían;
+            # playwright, si se puede navegar aunque se haya instalado o quitado durante la sesión;
+            # servers, los servicios MCP externos aunque otra pestaña los cambie o su proceso muera.
             self._send_json_response(200, {
                 "ok": True,
                 "cwd": str(Path.cwd().resolve()),
                 "jobs": [job.summary() for job in JOBS.running()],
-                "exit_on_close": EXIT_ON_CLOSE
+                "exit_on_close": EXIT_ON_CLOSE,
+                "playwright": playwright_status(),
+                "servers": GLOBAL_MCP_MANAGER.list_servers()
             })
             return
 
@@ -3597,7 +3695,6 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
             "version": VERSION,
             "cwd": str(Path.cwd().resolve()),
             "tools_count": len(LOCAL_TOOLS_DEFINITIONS),
-            "browser_action": browser_action_availability(),
             "os": DETECTED_OS
         })
         self._log_res(200, safe_path, (time.monotonic() - t0) * 1000)
@@ -3731,18 +3828,7 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
             }
             return self._initialize_result(server_info), None, ""
         if method == "tools/list":
-            browser_availability = browser_action_availability()
-            tools = []
-            for definition in LOCAL_TOOLS_DEFINITIONS:
-                item = dict(definition)
-                if item.get("name") == "browser_action":
-                    item["availability"] = browser_availability
-                tools.append(item)
-            return {"tools": tools}, None, ""
-        if method == "tools/availability":
-            if params.get("name", "") != "browser_action":
-                return None, {"code": -32602, "message": "Herramienta no compatible con comprobación de disponibilidad."}, ""
-            return browser_action_availability(), None, ""
+            return {"tools": [dict(definition) for definition in LOCAL_TOOLS_DEFINITIONS]}, None, ""
         if method == "tools/call":
             tool_name = params["name"]
             handler = LOCAL_TOOL_HANDLERS.get(tool_name)
@@ -3778,6 +3864,13 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
                 return None, {"code": -32602, "message": str(exc)}, ""
             except Exception as exc:
                 return None, {"code": -32603, "message": f"Error al abrir el visor de diffs: {exc}"}, str(exc)
+        if method == "zerochat/diff/configure":
+            try:
+                return configure_gui_diff_tool(params.get("tool")), None, ""
+            except (ValueError, RuntimeError) as exc:
+                return None, {"code": -32602, "message": str(exc)}, ""
+            except Exception as exc:
+                return None, {"code": -32603, "message": f"Error configurando el visor de diffs: {exc}"}, str(exc)
         if method == "zerochat/web/fetch":
             try:
                 return fetch_web_resource(params), None, ""
@@ -3789,8 +3882,6 @@ class ZeroChatServerHandler(BaseHTTPRequestHandler):
             return self._dispatch_jobs(method, params)
         if method.startswith("zerochat/run/"):
             return dispatch_run(method, params)
-        if method == "zerochat/external/status":
-            return {"host": "running", "version": VERSION, "servers": GLOBAL_MCP_MANAGER.list_servers()}, None, ""
         if method in ("zerochat/external/servers/start", "zerochat/external/servers/stop", "zerochat/external/servers/configure"):
             return self._dispatch_server_control(method, params)
         if method.startswith("zerochat/browser/"):