comate-cli 0.5.1__tar.gz → 0.5.2__tar.gz

{comate_cli-0.5.1 → comate_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.5.1
+Version: 0.5.2
 Summary: Comate terminal CLI built on comate-agent-sdk
 Project-URL: Homepage, https://github.com/AndyLee1024/agent-sdk
 Project-URL: Repository, https://github.com/AndyLee1024/agent-sdk
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.11
 Requires-Dist: charset-normalizer==3.4.7
 Requires-Dist: comate-agent-sdk<1.0.0,>=0.0.2
+Requires-Dist: concurrent-log-handler>=0.9.25
 Requires-Dist: curl-cffi==0.13.0
 Requires-Dist: packaging>=21.0
 Requires-Dist: pillow==12.2.0

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/mcp_cli.py

@@ -217,9 +217,17 @@ def _read_effective_server_with_source(
     return None
 
 
-def _render_health_status(connected: bool, reason: str | None) -> str:
-    if connected:
+def _render_health_status(
+    *,
+    status: str | None,
+    connected: bool,
+    reason: str | None,
+) -> str:
+    normalized = str(status or "").strip().lower()
+    if normalized == "connected" or (normalized in {"", "idle"} and connected):
         return "✓ Connected"
+    if normalized == "connecting":
+        return "… Connecting"
     if reason:
         return f"✗ {reason}"
     return "✗ Not connected"
@@ -294,7 +302,11 @@ def _cmd_list(args: argparse.Namespace, *, project_root: PathInput | None) -> No
         endpoint = _format_server_endpoint(cfg)
         health = health_by_alias.get(alias)
         status = (
-            _render_health_status(health.connected, health.reason)
+            _render_health_status(
+                status=getattr(health, "status", None),
+                connected=health.connected,
+                reason=health.reason,
+            )
             if health is not None
             else "✗ Unknown"
         )
@@ -330,7 +342,11 @@ def _cmd_get(args: argparse.Namespace, *, project_root: PathInput | None) -> Non
     status = "✗ Not connected"
     if health_rows:
         row = health_rows[0]
-        status = _render_health_status(row.connected, row.reason)
+        status = _render_health_status(
+            status=getattr(row, "status", None),
+            connected=row.connected,
+            reason=row.reason,
+        )
 
     server_type = str(cfg.get("type", "stdio")).strip().lower()  # type: ignore[attr-defined]
     lines = [

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/app.py

@@ -370,7 +370,7 @@ async def run(
     # 而非 fallthrough 到 Python lastResort StreamHandler 以原始文本输出到 stderr。
     renderer = EventRenderer(project_root=project_root)
     from comate_cli.terminal_agent.logging_adapter import setup_tui_logging
-    logging_session = setup_tui_logging(renderer)
+    logging_session = setup_tui_logging(renderer, project_root=project_root)
 
     session, mode = _resolve_session(agent, resume_session_id, cwd=project_root)
 

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/event_renderer.py

@@ -712,7 +712,39 @@ class EventRenderer:
 
         if lowered == "grep":
             lines = [line for line in (result or "").splitlines() if line.strip()]
-            return f"Found matches in {len(lines)} files"
+            if not lines:
+                return "Found matches"
+
+            count_summary = re.search(
+                r"^Found\s+(at least\s+)?(\d+)\s+total occurrences across\s+(\d+)\s+(file|files)\.",
+                result or "",
+                re.MULTILINE,
+            )
+            if count_summary:
+                qualifier = count_summary.group(1) or ""
+                occurrences = count_summary.group(2)
+                file_count = count_summary.group(3)
+                file_word = count_summary.group(4)
+                return f"Found {qualifier}{occurrences} matches across {file_count} {file_word}"
+
+            if lines[0] == "No matches found":
+                return "Found 0 matches"
+
+            if lines[0] == "No files found":
+                return "Found matches in 0 files"
+
+            file_summary = re.match(r"^Found\s+(at least\s+)?(\d+)\s+files?\b", lines[0])
+            if file_summary:
+                qualifier = file_summary.group(1) or ""
+                return f"Found matches in {qualifier}{file_summary.group(2)} files"
+
+            if all(
+                not re.search(r":\d+(?::|$)", line)
+                for line in lines
+            ):
+                return f"Found matches in {len(lines)} files"
+
+            return "Found matches"
 
         return None
 
@@ -729,7 +761,7 @@ class EventRenderer:
         Args:
             signature: 工具签名，例如 "Read(path=xxx)"
             is_error: 是否为错误结果
-            diff_lines: optional diff lines for Edit/MultiEdit
+            diff_lines: optional diff lines for Edit
             model_name: model name for Agent tools (rendered dim)
             subtitle: optional subtitle rendered as `⎿ ...`
         """
@@ -833,7 +865,7 @@ class EventRenderer:
         else:
             display_name = state.display_tool_name or state.tool_name
             summary = state.args_summary
-            # Append line range for Edit/MultiEdit
+            # Append line range for Edit
             if display_name == "Update" and metadata:
                 sl = metadata.get("start_line")
                 el = metadata.get("end_line")
@@ -843,7 +875,7 @@ class EventRenderer:
             signature = _tool_signature(display_name, summary)
             base = f"{signature}"
 
-        # Render diff for Edit/MultiEdit if metadata contains diff lines
+        # Render diff for Edit if metadata contains diff lines
         if not is_error and metadata:
             diff_lines = metadata.get("diff")
             if isinstance(diff_lines, list) and len(diff_lines) > 0:

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/logging_adapter.py

@@ -6,6 +6,7 @@ import os
 import sys
 import threading
 import time
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 from prompt_toolkit.application import run_in_terminal
@@ -14,6 +15,8 @@ if TYPE_CHECKING:
     from comate_cli.terminal_agent.event_renderer import EventRenderer
 
 
+logger = logging.getLogger(__name__)
+
 _COMATE_LOGGING_SESSION_MARKER = "_comate_tui_logging_session"
 _RECENT_DUPLICATE_LOG_WINDOW_SECONDS = 0.5
 _recent_log_message_times: dict[str, float] = {}
@@ -21,6 +24,11 @@ _recent_log_message_lock = threading.Lock()
 _active_tui_logging_session: "TUILoggingSession | None" = None
 _active_tui_logging_session_lock = threading.Lock()
 
+_LOG_LEVEL_ENV_VAR = "COMATE_LOG_LEVEL"
+_VALID_LOG_LEVELS: tuple[str, ...] = ("DEBUG", "INFO", "WARNING", "ERROR")
+_DEFAULT_LOG_LEVEL = logging.INFO
+_invalid_log_level_warned = False
+
 
 def _should_drop_recent_duplicate_log(msg_key: str) -> bool:
     now = time.monotonic()
@@ -193,19 +201,80 @@ class TUILoggingSession:
                 _active_tui_logging_session = None
 
 
-def _build_file_handler() -> logging.Handler:
-    from logging.handlers import RotatingFileHandler
+def _read_level_from_settings_env(project_root: Path | None) -> str:
+    """从 settings.json 的 env 段读取 COMATE_LOG_LEVEL。
+
+    查找顺序：project settings(.agent/settings.json) → user settings(~/.agent/settings.json)。
+    复用 SDK 侧的 load_settings_file，不引入独立解析路径。
+    返回空串表示未配置或读取失败，由调用方决定如何降级。
+    """
+    try:
+        from comate_agent_sdk.agent.settings import USER_SETTINGS_PATH, load_settings_file
+    except Exception:
+        return ""
+
+    def _lookup(path: Path) -> str:
+        try:
+            cfg = load_settings_file(path)
+        except Exception:
+            return ""
+        if cfg is None or cfg.env is None:
+            return ""
+        raw = cfg.env.get(_LOG_LEVEL_ENV_VAR, "")
+        return raw.strip() if isinstance(raw, str) else ""
+
+    if project_root is not None:
+        value = _lookup(Path(project_root) / ".agent" / "settings.json")
+        if value:
+            return value
+
+    return _lookup(USER_SETTINGS_PATH)
+
+
+def _resolve_log_level(project_root: Path | None = None) -> int:
+    """解析生效日志级别。
+
+    优先级：os.environ[COMATE_LOG_LEVEL]
+          > project .agent/settings.json env.COMATE_LOG_LEVEL
+          > user ~/.agent/settings.json env.COMATE_LOG_LEVEL
+          > INFO。
+    非法值降级 INFO，并在整个进程生命周期内最多 warn 一次。
+    """
+    global _invalid_log_level_warned
+
+    raw = os.environ.get(_LOG_LEVEL_ENV_VAR, "").strip()
+    if not raw:
+        raw = _read_level_from_settings_env(project_root)
+
+    if not raw:
+        return _DEFAULT_LOG_LEVEL
+
+    normalized = raw.upper()
+    if normalized not in _VALID_LOG_LEVELS:
+        if not _invalid_log_level_warned:
+            _invalid_log_level_warned = True
+            logger.warning(
+                f"Invalid {_LOG_LEVEL_ENV_VAR}={raw!r}; falling back to INFO. "
+                f"Valid values: {list(_VALID_LOG_LEVELS)}"
+            )
+        return _DEFAULT_LOG_LEVEL
+
+    return getattr(logging, normalized)
+
+
+def _build_file_handler(level: int) -> logging.Handler:
+    from concurrent_log_handler import ConcurrentRotatingFileHandler
 
     log_dir = os.path.join(os.path.expanduser("~"), ".comate", "logs")
     os.makedirs(log_dir, exist_ok=True)
     log_path = os.path.join(log_dir, "agent.log")
-    file_handler = RotatingFileHandler(
+    file_handler = ConcurrentRotatingFileHandler(
         log_path,
         maxBytes=10 * 1024 * 1024,
         backupCount=3,
         encoding="utf-8",
     )
-    file_handler.setLevel(logging.DEBUG)
+    file_handler.setLevel(level)
     file_handler.setFormatter(
         logging.Formatter("%(asctime)s %(levelname)s %(name)s: %(message)s")
     )
@@ -219,15 +288,26 @@ def _should_mute_terminal_stream(handler: logging.Handler) -> bool:
     return stream in {sys.stdout, sys.stderr, sys.__stdout__, sys.__stderr__}
 
 
-def setup_tui_logging(renderer: EventRenderer) -> TUILoggingSession:
+def setup_tui_logging(
+    renderer: EventRenderer,
+    *,
+    project_root: Path | None = None,
+) -> TUILoggingSession:
     """统一日志初始化：文件 + TUI 双通道。
 
-    - 所有日志（含 traceback）写入 ~/.comate/logs/agent.log（RotatingFileHandler）
+    - 所有日志（含 traceback）写入 ~/.comate/logs/agent.log
+      （ConcurrentRotatingFileHandler：跨进程文件锁 + Windows rename 重试）
     - WARNING/ERROR 以用户友好格式显示在 TUI scrollback
     - 临时静默 root logger 上写往 stdout/stderr 的 stream handler，避免污染 TUI
+
+    日志级别通过 COMATE_LOG_LEVEL 控制（默认 INFO，可设为 DEBUG/INFO/WARNING/ERROR）。
+    查找顺序：os.environ > project .agent/settings.json env > user ~/.agent/settings.json env。
+    root 与 file handler 同步应用该级别——第三方库（anthropic/httpx/...）的 DEBUG 噪音随之收敛。
+    TUI handler 始终固定 WARNING，不受此开关影响，避免 DEBUG 刷屏。
     """
     root = logging.getLogger()
     previous_level = root.level
+    level = _resolve_log_level(project_root)
 
     with _active_tui_logging_session_lock:
         global _active_tui_logging_session
@@ -254,10 +334,13 @@ def setup_tui_logging(renderer: EventRenderer) -> TUILoggingSession:
             continue
 
     # 1. 日志文件 handler（完整调试信息，含 traceback）
-    file_handler = _build_file_handler()
+    file_handler = _build_file_handler(level)
     setattr(file_handler, _COMATE_LOGGING_SESSION_MARKER, True)
     root.addHandler(file_handler)
-    root.setLevel(logging.DEBUG)
+    # root 级别与 file handler 保持一致——这是单 knob 控第三方 DEBUG 噪音的关键：
+    # 第三方 logger level=NOTSET 会继承 root 的 effective level，DEBUG 记录
+    # 在 isEnabledFor 阶段就被丢弃，不会走到任何 handler。
+    root.setLevel(level)
 
     # 2. TUI handler 挂到 root（覆盖所有命名空间的 WARNING/ERROR）
     tui_handler = TUILoggingHandler(renderer)

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/rewind_store.py

@@ -16,7 +16,7 @@ from comate_agent_sdk.context.items import ItemType
 
 logger = logging.getLogger(__name__)
 
-_TRACKED_TOOLS = {"Write", "Edit", "MultiEdit"}
+_TRACKED_TOOLS = {"Write", "Edit"}
 _SCHEMA_VERSION = 1
 
 
@@ -561,6 +561,8 @@ class RewindStore:
             touched.add(relpath)
 
             created_val = data.get("created")
+            if not isinstance(created_val, bool):
+                created_val = meta.get("created")
             created: bool | None
             if isinstance(created_val, bool):
                 created = created_val

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/tool_view.py

@@ -63,7 +63,7 @@ _ALLOWED_PRIORITY = {"high", "medium", "low"}
 # Tools that are always hidden from scrollback (have dedicated event channels).
 _ALWAYS_HIDDEN_TOOLS: frozenset[str] = frozenset({"askuserquestion", "exitplanmode"})
 
-# Task coordination tools hidden from scrollback unless erroring.
+# Task coordination tools hidden from scrollback unless explicitly surfaced.
 _SILENT_TASK_TOOLS: frozenset[str] = frozenset({
     "taskcreate", "taskupdate", "tasklist", "taskget",
 })
@@ -149,13 +149,13 @@ def extract_todos(args: dict[str, Any]) -> list[TodoItemState] | None:
     return todos
 
 
-def _truncate(content: str, max_len: int = 280) -> str:
+def _truncate(content: str, max_len: int = 400) -> str:
     if len(content) <= max_len:
         return content
     return f"{content[:max_len - 3]}..."
 
 
-TOOL_SUMMARY_MAX_LENGTH = 50
+TOOL_SUMMARY_MAX_LENGTH = 160
 
 
 def _truncate_path_middle(path: str | None, max_len: int) -> str:
@@ -206,12 +206,22 @@ def _compact_json(value: Any, max_len: int = 220) -> str:
     return _truncate(content, max_len=max_len)
 
 
+def _summarize_env_vars(value: Any, max_len: int = 120) -> str:
+    if not isinstance(value, dict) or not value:
+        return ""
+    parts: list[str] = []
+    for key in sorted(value):
+        rendered = f"{key}={value[key]}"
+        parts.append(_truncate(str(rendered), 48))
+    return _truncate(",".join(parts), max_len=max_len)
+
+
 def _friendly_kv(args: dict[str, Any], max_len: int = 220) -> str:
     """将 dict 格式化为 key: "value" 的友好显示格式。"""
     parts: list[str] = []
     for k, v in args.items():
         if isinstance(v, str):
-            parts.append(f'{k}: "{_truncate(v, 80)}"')
+            parts.append(f'{k}: "{_truncate(v, 160)}"')
         else:
             parts.append(f"{k}: {v}")
     result = ", ".join(parts)
@@ -363,30 +373,30 @@ def summarize_tool_args(
     if lowered == "write":
         path = _lookup_arg(args, "file_path", "path")
         path_display = _truncate_path_middle(
-            _normalize_path_for_display(path, project_root) or "", 45
+            _normalize_path_for_display(path, project_root) or "", 120
         )
         return _truncate(f"path={path_display}" if path_display else _compact_json(args), TOOL_SUMMARY_MAX_LENGTH)
     if lowered == "edit":
         path = _lookup_arg(args, "file_path", "path")
         path_display = _truncate_path_middle(
-            _normalize_path_for_display(path, project_root) or "", 45
+            _normalize_path_for_display(path, project_root) or "", 120
         )
         return _truncate(path_display or _compact_json(args), TOOL_SUMMARY_MAX_LENGTH)
     if lowered == "multiedit":
         path = _lookup_arg(args, "file_path", "path")
         path_display = _truncate_path_middle(
-            _normalize_path_for_display(path, project_root) or "", 45
+            _normalize_path_for_display(path, project_root) or "", 120
         )
         return _truncate(path_display or _compact_json(args), TOOL_SUMMARY_MAX_LENGTH)
     if lowered == "read":
         path = _lookup_arg(args, "file_path", "path")
         path_display = _truncate_path_middle(
-            _normalize_path_for_display(path, project_root) or "", 40
+            _normalize_path_for_display(path, project_root) or "", 120
         )
-        offset = _lookup_arg(args, "offset_line")
-        limit = _lookup_arg(args, "limit_lines")
+        offset = _lookup_arg(args, "offset", "offset_line")
+        limit = _lookup_arg(args, "limit", "limit_lines")
         raw = f"path={path_display} offset={offset} limit={limit}" if path_display else _compact_json(args)
-        return _truncate(raw, 65)
+        return _truncate(raw, 160)
     if lowered == "agent":
         subagent_name, description = _extract_task_identity(args)
         if description and description != subagent_name:
@@ -421,9 +431,9 @@ def summarize_tool_args(
         pattern = _lookup_arg(args, "pattern")
         path = _lookup_arg(args, "path")
         path_display = _truncate_path_middle(
-            _normalize_path_for_display(path, project_root) or "", 25
+            _normalize_path_for_display(path, project_root) or "", 80
         )
-        pattern_display = _truncate(str(pattern), 20) if pattern else ""
+        pattern_display = _truncate(str(pattern), 60) if pattern else ""
         parts = []
         if path_display:
             parts.append(f"path={path_display}")
@@ -432,21 +442,34 @@ def summarize_tool_args(
         return _truncate(" ".join(parts) if parts else _compact_json(args), TOOL_SUMMARY_MAX_LENGTH)
     if lowered == "bash":
         command_args = _lookup_arg(args, "args")
+        env_summary = _summarize_env_vars(_lookup_arg(args, "env"))
         if isinstance(command_args, list):
             cmd = " ".join(str(part) for part in command_args)
-            cmd_display = _truncate(cmd, 120)
+            cmd_display = _truncate(cmd, 200)
             cwd = _lookup_arg(args, "cwd")
             cwd_display = _normalize_cwd_for_display(cwd, project_root)
+            prefix_parts = []
             if cwd_display:
-                return _truncate(f"cwd={cwd_display} {cmd_display}", 120)
+                prefix_parts.append(f"cwd={cwd_display}")
+            if env_summary:
+                prefix_parts.append(f"env={env_summary}")
+            if prefix_parts:
+                return _truncate(f"{' '.join(prefix_parts)} {cmd_display}", 200)
             return cmd_display
         # 回退：兼容非标准格式（如 command 字段）
         command = _lookup_arg(args, "command")
         cwd = _lookup_arg(args, "cwd")
         cwd_display = _normalize_cwd_for_display(cwd, project_root)
+        prefix_parts = []
         if cwd_display:
-            return _truncate(f"cwd={cwd_display} command={_truncate(str(command), 120)}", 120) if command else _compact_json(args)
-        return _truncate(f"command={_truncate(str(command), 120)}", 120) if command else _compact_json(args)
+            prefix_parts.append(f"cwd={cwd_display}")
+        if env_summary:
+            prefix_parts.append(f"env={env_summary}")
+        if prefix_parts and command:
+            return _truncate(f"{' '.join(prefix_parts)} command={_truncate(str(command), 200)}", 200)
+        if prefix_parts:
+            return _truncate(" ".join(prefix_parts), 200)
+        return _truncate(f"command={_truncate(str(command), 200)}", 200) if command else _compact_json(args)
     if lowered == "skill":
         skill_name = _lookup_arg(args, "skill_name", "skill")
         return _truncate(str(skill_name).strip(), TOOL_SUMMARY_MAX_LENGTH) if skill_name else ""

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/tui.py

@@ -101,17 +101,25 @@ def _truncate_file_history(path: Path, max_entries: int = 200) -> None:
     """Truncate a prompt_toolkit FileHistory file to at most max_entries."""
     if not path.exists():
         return
-    content = path.read_text()
-    if not content.strip():
+    raw = path.read_bytes()
+    if not raw.strip():
         return
+    content = raw.decode("utf-8")
+    normalized = content.replace("\r\n", "\n").replace("\r", "\n")
     # FileHistory format: entries are +prefixed line blocks separated by blank lines
-    blocks = content.split("\n\n")
+    blocks = normalized.split("\n\n")
     # Filter out empty blocks
     blocks = [b for b in blocks if b.strip()]
-    if len(blocks) <= max_entries:
+    if not blocks:
         return
     kept = blocks[-max_entries:]
-    path.write_text("\n\n".join(kept) + "\n\n")
+    rewritten = "\n\n".join(kept) + "\n\n"
+    rewritten_bytes = rewritten.encode("utf-8")
+    if rewritten_bytes == raw:
+        return
+    # Canonicalize to UTF-8 + LF so prompt_toolkit can reload history consistently
+    # across platforms, including Windows.
+    path.write_bytes(rewritten_bytes)
 
 
 class TerminalAgentTUI(
@@ -739,11 +747,18 @@ class TerminalAgentTUI(
             session_cwd = getattr(self._session, "_cwd", None)
             cwd = str(Path(session_cwd).expanduser().resolve()) if session_cwd else str(Path.cwd().resolve())
             history_path = _get_input_history_path(cwd)
-            _truncate_file_history(history_path, _INPUT_HISTORY_MAX_ENTRIES)
-            return FileHistory(str(history_path))
         except Exception:
             logger.debug("Failed to create FileHistory, falling back to InMemoryHistory", exc_info=True)
             return InMemoryHistory()
+        try:
+            _truncate_file_history(history_path, _INPUT_HISTORY_MAX_ENTRIES)
+        except Exception:
+            logger.warning(
+                "Failed to normalize input history file %s; continuing with FileHistory",
+                history_path,
+                exc_info=True,
+            )
+        return FileHistory(str(history_path))
 
     def _input_placeholder_hint(self) -> str | None:
         if self._ui_mode != UIMode.NORMAL:

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/tui_parts/commands.py

@@ -231,6 +231,7 @@ class CommandsMixin:
         manager = getattr(self._session._agent, "_mcp_manager", None)
         info_rows = list(getattr(manager, "tool_infos", []) or []) if manager is not None else []
         failed_rows = list(getattr(manager, "failed_servers", []) or []) if manager is not None else []
+        state_rows = dict(getattr(manager, "server_states", {}) or {}) if manager is not None else {}
 
         tools_by_alias: dict[str, list[dict[str, str]]] = {}
         tool_count_by_alias: dict[str, int] = {}
@@ -262,13 +263,32 @@ class CommandsMixin:
             tool_count = int(tool_count_by_alias.get(alias, 0))
             tools = list(tools_by_alias.get(alias, []))
             tools.sort(key=lambda item: item["remote_name"].lower())
+            state = state_rows.get(alias)
+            raw_status = str(getattr(state, "status", "") or "").strip().lower()
+            state_reason = str(getattr(state, "reason", "") or "").strip() or None
+            state_tool_count = int(getattr(state, "tool_count", tool_count) or 0)
+            if raw_status == "connected":
+                tool_count = state_tool_count
 
             if alias in failed_reason_by_alias:
                 status = f"✗ {failed_reason_by_alias[alias]}"
+                raw_status = "failed"
             elif manager is None:
                 status = "… Not initialized"
-            else:
+                raw_status = "idle"
+            elif raw_status == "connecting":
+                status = "… Connecting"
+            elif raw_status == "failed":
+                status = f"✗ {state_reason}" if state_reason else "✗ Not connected"
+                tool_count = 0
+            elif raw_status == "connected":
                 status = "✓ Connected"
+            elif tool_count > 0:
+                status = "✓ Connected"
+                raw_status = "connected"
+            else:
+                status = "… Not initialized"
+                raw_status = "idle"
 
             if alias in project_servers:
                 config_location = str(project_path)
@@ -283,6 +303,7 @@ class CommandsMixin:
                     "server_type": server_type,
                     "endpoint": endpoint or "(empty)",
                     "status": status,
+                    "raw_status": raw_status,
                     "tool_count": tool_count,
                     "tools": tools,
                     "config_location": config_location,
@@ -376,7 +397,8 @@ class CommandsMixin:
 
         tool_count = int(row["tool_count"])
         options: list[dict[str, str]] = []
-        if tool_count > 0:
+        raw_status = str(row.get("raw_status", "")).strip().lower()
+        if raw_status == "connected" and tool_count > 0:
             options.append(
                 {
                     "value": "view_tools",
@@ -384,13 +406,14 @@ class CommandsMixin:
                     "description": f"{tool_count} tools",
                 }
             )
-        options.append(
-            {
-                "value": "reconnect",
-                "label": "Reconnect",
-                "description": "Reconnect to this server",
-            }
-        )
+        if raw_status != "connecting":
+            options.append(
+                {
+                    "value": "reconnect",
+                    "label": "Reconnect",
+                    "description": "Reconnect to this server",
+                }
+            )
         options.append(
             {
                 "value": "back",
@@ -454,6 +477,9 @@ class CommandsMixin:
     def _start_mcp_reconnect(self, alias: str, rows_by_alias: dict[str, dict[str, Any]]) -> None:
         """启动 MCP server 重连流程。"""
         agent_runtime = self._session._agent
+        row = rows_by_alias.get(alias, {})
+        server_type = str(row.get("server_type", "")).strip().upper()
+        connect_timeout_s = 30.0 if server_type in {"STDIO", "SDK"} else 10.0
 
         def on_done(success: bool, error_message: str) -> None:
             if success:
@@ -492,7 +518,12 @@ class CommandsMixin:
                 )
 
         retry_coro = agent_runtime.retry_mcp_server(alias)
-        self._mcp_connecting_view.enter(alias, retry_coro, on_done)
+        self._mcp_connecting_view.enter(
+            alias,
+            retry_coro,
+            on_done,
+            timeout_s=connect_timeout_s,
+        )
         self._ui_mode = UIMode.MCP_CONNECTING
         self._sync_focus_for_mode()
         self._invalidate()

{comate_cli-0.5.1 → comate_cli-0.5.2}/comate_cli/terminal_agent/tui_parts/history_sync.py

@@ -9,6 +9,7 @@ from prompt_toolkit.application import run_in_terminal
 from rich.console import Console
 
 from comate_agent_sdk.context.items import ItemType
+from comate_agent_sdk.context.items import TOOL_OBSERVABLE_INPUTS_METADATA_KEY
 from comate_agent_sdk.llm.messages import AssistantMessage, UserMessage
 
 from comate_cli.terminal_agent.history_printer import (
@@ -102,6 +103,13 @@ class HistorySyncMixin:
                             args_dict = json.loads(args_str) if args_str else {}
                         except json.JSONDecodeError:
                             args_dict = {"_raw": args_str}
+                        observable_inputs = (getattr(item, "metadata", {}) or {}).get(
+                            TOOL_OBSERVABLE_INPUTS_METADATA_KEY
+                        )
+                        if isinstance(observable_inputs, dict):
+                            observable_input = observable_inputs.get(tc.id)
+                            if isinstance(observable_input, dict):
+                                args_dict = observable_input
                         signature = self._build_resume_tool_signature(tool_name, args_dict)
                         # 存储映射，不调用 restore_tool_call（避免加入 _running_tools）
                         tool_call_info[tc.id] = (tool_name, signature)
@@ -138,9 +146,9 @@ class HistorySyncMixin:
                 # Extract metadata from ContextItem
                 item_metadata = getattr(item, "metadata", {}) or {}
 
-                # Extract diff from raw_envelope for Edit/MultiEdit
+                # Extract diff from raw_envelope for Edit
                 diff_lines: list[str] | None = None
-                if tool_name in ("Edit", "MultiEdit") and not is_error:
+                if tool_name == "Edit" and not is_error:
                     envelope = item_metadata.get("tool_raw_envelope")
                     if isinstance(envelope, dict):
                         data = envelope.get("data", {})