chore(plugin): improve config write diagnostics (#1675)

Co-authored-by: LocalBuilder <local@builder>

Author: wislap

plugin/plugins/mcp_adapter/__init__.py

@@ -2082,6 +2082,10 @@ async def add_server(
         try:
             await self._persist_servers_config(servers_config)
         except Exception as exc:
+            self.ctx.logger.exception(
+                f"Failed to persist MCP server config while adding server '{name}' "
+                f"(transport={transport}): {exc}"
+            )
             return Err(SdkError(f"Failed to save server config: {exc}"))
 
         # 缓存配置
@@ -2154,6 +2158,10 @@ async def remove_servers(self, server_names: List[str], **_):
         try:
             await self._persist_servers_config(dict(servers_config))
         except Exception as exc:
+            self.ctx.logger.exception(
+                "Failed to persist MCP server config while removing servers "
+                f"(requested={len(server_names)}, removed={len(removed)}): {exc}"
+            )
             return Err(SdkError(f"Failed to save server config: {exc}"))
         self._servers_config = servers_config
 

plugin/server/application/plugins/ui_query_service.py

@@ -6,6 +6,7 @@
 from pathlib import Path
 
 from plugin.core.state import state
+from plugin._types.exceptions import PluginExecutionError
 from plugin._types.models import PluginUiSurface, PluginUiWarning
 from plugin.logging_config import get_logger
 from plugin.core.ui_manifest import (
@@ -910,7 +911,32 @@ async def call_surface_action(
                     details={"plugin_id": plugin_id, "kind": kind, "surface_id": surface_id, "action_id": action_id},
                 )
 
-            result = await host.trigger(resolved_action_id, dict(args or {}))
+            try:
+                result = await host.trigger(resolved_action_id, dict(args or {}))
+            except PluginExecutionError as exc:
+                message = exc.error if isinstance(exc.error, str) and exc.error else str(exc)
+                logger.warning(
+                    "Hosted UI action failed in plugin entry: plugin_id={}, surface={}:{}, action_id={}, entry_id={}, err={}",
+                    plugin_id,
+                    kind,
+                    surface_id,
+                    action_id,
+                    resolved_action_id,
+                    message,
+                )
+                raise ServerDomainError(
+                    code="PLUGIN_UI_ACTION_FAILED",
+                    message=message,
+                    status_code=500,
+                    details={
+                        "plugin_id": plugin_id,
+                        "kind": kind,
+                        "surface_id": surface_id,
+                        "action_id": action_id,
+                        "entry_id": resolved_action_id,
+                        "error_type": type(exc).__name__,
+                    },
+                ) from exc
             return {
                 "plugin_id": plugin_id,
                 "action_id": resolved_action_id,

plugin/server/infrastructure/config_paths.py

@@ -6,8 +6,11 @@
 from fastapi import HTTPException
 
 from plugin.core.state import state
+from plugin.logging_config import get_logger
 from plugin.settings import PLUGIN_CONFIG_ROOTS
 
+logger = get_logger("server.infrastructure.config_paths")
+
 
 def _resolve_registered_plugin_config_path(plugin_id: str) -> Path | None:
     candidates: list[object] = []
@@ -29,10 +32,30 @@ def _resolve_registered_plugin_config_path(plugin_id: str) -> Path | None:
             continue
         try:
             path = Path(candidate).resolve()
-        except (TypeError, ValueError, OSError, RuntimeError):
+        except (TypeError, ValueError, OSError, RuntimeError) as exc:
+            logger.warning(
+                "Plugin config registered path ignored: plugin_id={}, candidate_type={}, err_type={}, err={}",
+                plugin_id,
+                type(candidate).__name__,
+                type(exc).__name__,
+                str(exc),
+            )
             continue
         if path.is_file() and path.name == "plugin.toml":
+            logger.debug(
+                "Plugin config path resolved from registered metadata: plugin_id={}, config_path={}",
+                plugin_id,
+                path,
+            )
             return path
+        logger.warning(
+            "Plugin config registered path ignored: plugin_id={}, config_path={}, exists={}, is_file={}, name={}",
+            plugin_id,
+            path,
+            path.exists(),
+            path.is_file(),
+            path.name,
+        )
 
     return None
 
@@ -72,6 +95,12 @@ def get_plugin_config_path(plugin_id: str) -> Path:
                 continue
 
         if config_file.exists():
+            logger.debug(
+                "Plugin config path resolved from config root: plugin_id={}, root={}, config_path={}",
+                plugin_id,
+                root,
+                config_file,
+            )
             return config_file
 
     raise HTTPException(

plugin/server/infrastructure/config_storage.py

@@ -32,21 +32,40 @@ def atomic_write_bytes(*, target: Path, payload: bytes, prefix: str) -> None:
             dir=str(target.parent),
         )
     except OSError as exc:
+        logger.exception(
+            "Failed to create temporary config file: target={}, parent={}, prefix={}, err_type={}, err={}",
+            target,
+            target.parent,
+            prefix,
+            type(exc).__name__,
+            str(exc),
+        )
         raise HTTPException(
             status_code=500,
-            detail=f"Failed to create temporary file for {target}",
+            detail=f"Failed to create temporary file for {target}: {type(exc).__name__}: {exc}",
         ) from exc
 
     temp_file_path = Path(temp_path)
+    stage = "write_temp"
     try:
         with os.fdopen(temp_fd, "wb") as temp_file:
             temp_file.write(payload)
             temp_file.flush()
             os.fsync(temp_file.fileno())
 
+        stage = "replace"
         os.replace(temp_file_path, target)
+        stage = "fsync_parent"
         _fsync_parent_dir(target)
     except (OSError, RuntimeError, ValueError, TypeError) as exc:
+        logger.exception(
+            "Failed to persist config file: target={}, temp_path={}, stage={}, err_type={}, err={}",
+            target,
+            temp_file_path,
+            stage,
+            type(exc).__name__,
+            str(exc),
+        )
         try:
             if temp_file_path.exists():
                 temp_file_path.unlink()
@@ -58,7 +77,7 @@ def atomic_write_bytes(*, target: Path, payload: bytes, prefix: str) -> None:
             )
         raise HTTPException(
             status_code=500,
-            detail=f"Failed to persist config file {target}",
+            detail=f"Failed to persist config file {target} while {stage}: {type(exc).__name__}: {exc}",
         ) from exc