comate-cli 0.8.4__tar.gz → 0.8.6__tar.gz

{comate_cli-0.8.4 → comate_cli-0.8.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.8.4
+Version: 0.8.6
 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
@@ -18,6 +18,7 @@ Requires-Dist: charset-normalizer==3.4.7
 Requires-Dist: comate-agent-sdk<0.9.20,>=0.8.0a1
 Requires-Dist: concurrent-log-handler>=0.9.25
 Requires-Dist: curl-cffi==0.13.0
+Requires-Dist: httpx<0.29.0,>=0.28.1
 Requires-Dist: packaging>=21.0
 Requires-Dist: pillow==12.2.0
 Requires-Dist: prompt-toolkit>=3.0

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/error_display.py

@@ -1,7 +1,8 @@
 """Unified error formatter for terminal agent."""
 from __future__ import annotations
 
-import re
+import ast
+import json
 
 
 def format_error(exc: Exception) -> tuple[str, str, str]:
@@ -42,27 +43,14 @@ def format_error(exc: Exception) -> tuple[str, str, str]:
 
     if exc_type == "ModelProviderError":
         code = getattr(exc, "status_code", None)
-
-        # Context size exceeded (400 with specific body pattern)
-        if code == 400:
-            ctx = _parse_context_size_error(exc_msg)
-            if ctx:
-                return (
-                    f"Request ({ctx[0]} tokens) exceeds context limit ({ctx[1]})",
-                    "Context limit exceeded",
-                    "error",
-                )
-            return f"API error: {exc_msg}", "API error", "error"
-
-        if code == 401:
-            return "Invalid or expired API key", "Auth failed", "error"
-        if code == 403:
-            return "Access denied to this model", "Access denied", "error"
-        if code == 404:
-            return "Model not found or invalid API path", "Model not found", "error"
-        if code and code >= 500:
-            return f"Server error ({code})", "Server error", "warning"
-        return f"API error: {exc_msg}", "API error", "error"
+        detail = _provider_error_detail(exc_msg)
+        status = f" (HTTP {code})" if code is not None else ""
+        message = f"Provider error{status}"
+        if detail:
+            message = f"{message}: {detail}"
+        transient = f"Provider error {code}" if code is not None else "Provider error"
+        severity = "warning" if code is not None and code >= 500 else "error"
+        return message, transient, severity
 
     # Session errors
     if exc_type == "ChatSessionClosedError":
@@ -79,23 +67,34 @@ def format_error(exc: Exception) -> tuple[str, str, str]:
     return f"Error: {exc_msg}", "Error occurred", "error"
 
 
-def _parse_context_size_error(msg: str) -> tuple[str, str] | None:
-    """Extract (prompt_tokens, ctx_limit) from context size error body.
-
-    Matches patterns like 'n_prompt_tokens': 35099, 'n_ctx': 32768
-    or 'request (35099 tokens) exceeds the available context size (32768 tokens)'.
-    """
-    m = re.search(r"n_prompt_tokens['\"]?:\s*(\d+)", msg)
-    n = re.search(r"n_ctx['\"]?:\s*(\d+)", msg)
-    if m and n:
-        return m.group(1), n.group(1)
-
-    m2 = re.search(r"request\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
-    n2 = re.search(r"context\s*size\s*\((\d+)\s*tokens?\)", msg, re.IGNORECASE)
-    if m2 and n2:
-        return m2.group(1), n2.group(1)
-
-    if "exceed_context_size_error" in msg:
-        return None  # Type matches but can't parse numbers — fall through to generic 400
-
+def _provider_error_detail(msg: str) -> str:
+    """Return provider-supplied detail, unwrapped from common SDK envelopes."""
+    text = str(msg or "").strip()
+    if not text:
+        return ""
+
+    candidates = [text]
+    if " - " in text:
+        candidates.append(text.split(" - ", 1)[1].strip())
+
+    for candidate in candidates:
+        detail = _error_message_from_mapping_text(candidate)
+        if detail:
+            return detail
+    return text
+
+
+def _error_message_from_mapping_text(text: str) -> str | None:
+    for parser in (json.loads, ast.literal_eval):
+        try:
+            value = parser(text)
+        except (ValueError, SyntaxError, TypeError):
+            continue
+        if not isinstance(value, dict):
+            continue
+        error = value.get("error")
+        if isinstance(error, dict):
+            message = error.get("message")
+            if isinstance(message, str) and message.strip():
+                return message.strip()
     return None

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/event_renderer.py

@@ -120,10 +120,10 @@ def _format_duration(seconds: float) -> str:
     minutes = int(elapsed // 60)
     remaining_seconds = int(elapsed % 60)
     if minutes < 60:
-        return f"{minutes}m{remaining_seconds:02d}s"
+        return f"{minutes}m {remaining_seconds:02d}s"
     hours = minutes // 60
     remaining_minutes = minutes % 60
-    return f"{hours}h{remaining_minutes:02d}m"
+    return f"{hours}h {remaining_minutes:02d}m"
 
 
 def _format_tokens(token_count: int) -> str:

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/status_bar.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
+import os
 import subprocess
 import time
 from pathlib import Path
@@ -22,11 +24,17 @@ class GitDiffStats(NamedTuple):
     removed: int
 
 
+class _GitCommandResult(NamedTuple):
+    returncode: int
+    stdout: str
+
+
 class StatusBar:
     _DEFAULT_TERMINAL_WIDTH: int = 100
     _MIN_TERMINAL_WIDTH: int = 40
     _GIT_DIFF_CACHE_SECONDS: float = 5.0
     _GIT_CMD_TIMEOUT_SECONDS: float = 0.2
+    _GIT_FAILURE_BACKOFF_SECONDS: float = 30.0
     _SEPARATOR: str = " \u00b7 "  # " · "
 
     # 分组颜色
@@ -46,6 +54,7 @@ class StatusBar:
         self._context_left_pct: float = 100.0
         self._git_diff_stats: GitDiffStats | None = None
         self._git_diff_cache_time: float = 0.0
+        self._git_failure_backoff_until: float = 0.0
         self._transient_message: str | None = None
         self._transient_severity: str = "info"
         self._transient_until: float | None = None
@@ -129,43 +138,76 @@ class StatusBar:
         normalized = str(mode).strip().lower()
         self._mode = normalized or "act"
 
-    @staticmethod
-    def _resolve_git_branch() -> str:
+    def _git_backoff_active(self) -> bool:
+        return time.monotonic() < self._git_failure_backoff_until
+
+    def _record_git_failure_backoff(self, *, reason: str, args: tuple[str, ...]) -> None:
+        self._git_failure_backoff_until = (
+            time.monotonic() + self._GIT_FAILURE_BACKOFF_SECONDS
+        )
+        logger.debug(
+            "status bar git refresh disabled temporarily: reason=%s args=%s",
+            reason,
+            " ".join(args),
+        )
+
+    async def _run_git_command(self, *args: str) -> _GitCommandResult | None:
+        if self._git_backoff_active():
+            return None
+
+        env = os.environ.copy()
+        env.setdefault("GIT_TERMINAL_PROMPT", "0")
+        env.setdefault("GIT_OPTIONAL_LOCKS", "0")
+        env.setdefault("GCM_INTERACTIVE", "Never")
+        proc: asyncio.subprocess.Process | None = None
         try:
-            completed = subprocess.run(
-                ["git", "branch", "--show-current"],
-                check=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                timeout=StatusBar._GIT_CMD_TIMEOUT_SECONDS,
+            proc = await asyncio.create_subprocess_exec(
+                "git",
+                *args,
+                stdin=subprocess.DEVNULL,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
+                env=env,
             )
-        except subprocess.TimeoutExpired:
-            return "N/A"
+            stdout, _stderr = await asyncio.wait_for(
+                proc.communicate(),
+                timeout=self._GIT_CMD_TIMEOUT_SECONDS,
+            )
+        except asyncio.TimeoutError:
+            self._record_git_failure_backoff(reason="timeout", args=args)
+            if proc is not None and proc.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    proc.kill()
+                with contextlib.suppress(Exception):
+                    await asyncio.wait_for(proc.wait(), timeout=0.2)
+            return None
         except Exception:
-            return "N/A"
+            self._record_git_failure_backoff(reason="error", args=args)
+            if proc is not None and proc.returncode is None:
+                with contextlib.suppress(ProcessLookupError):
+                    proc.kill()
+                with contextlib.suppress(Exception):
+                    await asyncio.wait_for(proc.wait(), timeout=0.2)
+            return None
+
+        return _GitCommandResult(
+            returncode=int(proc.returncode or 0),
+            stdout=stdout.decode("utf-8", errors="replace"),
+        )
 
+    async def _resolve_git_branch(self) -> str:
+        completed = await self._run_git_command("branch", "--show-current")
+        if completed is None:
+            return "N/A"
         if completed.returncode != 0:
             return "N/A"
         branch = completed.stdout.strip()
         return branch or "N/A"
 
-    @staticmethod
-    def _resolve_git_diff_stats() -> GitDiffStats | None:
-        try:
-            completed = subprocess.run(
-                ["git", "diff", "--shortstat", "--no-color"],
-                check=False,
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                timeout=StatusBar._GIT_CMD_TIMEOUT_SECONDS,
-            )
-        except subprocess.TimeoutExpired:
-            return None
-        except Exception:
+    async def _resolve_git_diff_stats(self) -> GitDiffStats | None:
+        completed = await self._run_git_command("diff", "--shortstat", "--no-color")
+        if completed is None:
             return None
-
         if completed.returncode != 0:
             return None
 
@@ -185,16 +227,6 @@ class StatusBar:
 
         return GitDiffStats(added=added, removed=removed)
 
-    def _ensure_git_diff_stats(self) -> None:
-        now = time.monotonic()
-        if (
-            self._git_diff_stats is not None
-            and now - self._git_diff_cache_time < self._GIT_DIFF_CACHE_SECONDS
-        ):
-            return
-        self._git_diff_stats = self._resolve_git_diff_stats()
-        self._git_diff_cache_time = now
-
     def _resolve_llm_level(self) -> str:
         agent = getattr(self._session, "_agent", None)
         level = getattr(agent, "level", None)
@@ -294,23 +326,37 @@ class StatusBar:
         except Exception:
             pass
 
-        branch_task = asyncio.to_thread(self._resolve_git_branch)
+        cfg = self._config
+        branch_task = (
+            asyncio.create_task(self._resolve_git_branch())
+            if cfg.show_git_branch
+            else None
+        )
         now = time.monotonic()
         diff_is_stale = (
-            self._git_diff_stats is None
-            or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+            cfg.show_git_diff
+            and (
+                self._git_diff_stats is None
+                or now - self._git_diff_cache_time >= self._GIT_DIFF_CACHE_SECONDS
+            )
         )
-        if diff_is_stale:
-            diff_task = asyncio.to_thread(self._resolve_git_diff_stats)
+        diff_task = (
+            asyncio.create_task(self._resolve_git_diff_stats())
+            if diff_is_stale
+            else None
+        )
+        if branch_task is not None and diff_task is not None:
             branch, diff_stats = await asyncio.gather(branch_task, diff_task)
+            self._git_branch = branch
             self._git_diff_stats = diff_stats
             self._git_diff_cache_time = time.monotonic()
-        else:
-            branch = await branch_task
-        self._git_branch = branch
+        elif branch_task is not None:
+            self._git_branch = await branch_task
+        elif diff_task is not None:
+            self._git_diff_stats = await diff_task
+            self._git_diff_cache_time = time.monotonic()
 
         # Refresh token usage cache if any token-related items are enabled.
-        cfg = self._config
         wants_token_counts = cfg.show_token_usage or cfg.show_token_input or cfg.show_token_output
         wants_cost = cfg.show_session_cost
         if wants_cost:

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/tool_view.py

@@ -333,10 +333,10 @@ def _format_duration(seconds: float) -> str:
     minutes = int(elapsed // 60)
     remaining_seconds = int(elapsed % 60)
     if minutes < 60:
-        return f"{minutes}m{remaining_seconds:02d}s"
+        return f"{minutes}m {remaining_seconds:02d}s"
     hours = minutes // 60
     remaining_minutes = minutes % 60
-    return f"{hours}h{remaining_minutes:02d}m"
+    return f"{hours}h {remaining_minutes:02d}m"
 
 
 def _sweep_gradient_text(content: str, frame: int) -> Text:

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/tui.py

@@ -186,6 +186,7 @@ class TerminalAgentTUI(
     RenderPanelsMixin,
 ):
     _NON_BLOCKING_UI_MODES = frozenset({UIMode.NORMAL})
+    _STATUS_REFRESH_TIMEOUT_SECONDS = 0.3
 
     def __init__(
         self,
@@ -206,6 +207,7 @@ class TerminalAgentTUI(
             set_tool_result_registry(self._tool_result_registry)
         self._task_poll_next_at = time.monotonic() + _TASK_POLL_INTERVAL_S
         self._task_poll_last_list_id: str | None = None
+        self._status_refresh_timeout_s = self._STATUS_REFRESH_TIMEOUT_SECONDS
 
         self._bind_team_message_callback(self._session)
 
@@ -1491,10 +1493,32 @@ class TerminalAgentTUI(
         self._interrupt_requested_at = None
         self._allow_latest_recall_on_interrupt = False
         self._set_busy(False)
-        await self._status_bar.refresh()
+        await self._refresh_status_bar_safely(reason="error-cleanup")
         self._renderer.clear_auto_compacting()
         self._refresh_layers()
 
+    async def _refresh_status_bar_safely(self, *, reason: str) -> None:
+        try:
+            timeout_s = max(
+                0.01,
+                float(getattr(self, "_status_refresh_timeout_s", 0.3)),
+            )
+            await asyncio.wait_for(
+                self._status_bar.refresh(),
+                timeout=timeout_s,
+            )
+        except asyncio.TimeoutError:
+            logger.debug(
+                "TUI status bar refresh timed out during %s; continuing event pump",
+                reason,
+            )
+        except Exception:
+            logger.warning(
+                "TUI status bar refresh failed during %s; continuing event pump",
+                reason,
+                exc_info=True,
+            )
+
     async def _submit_user_message(
         self,
         text: str,
@@ -1646,7 +1670,7 @@ class TerminalAgentTUI(
                         f"✻ Running scheduled task ({self._format_scheduled_fire_time()})"
                     )
                 if isinstance(event, GoalUpdatedEvent):
-                    await self._status_bar.refresh()
+                    await self._refresh_status_bar_safely(reason="goal-update")
                     self._refresh_layers()
                     self._invalidate()
                     continue
@@ -1730,7 +1754,7 @@ class TerminalAgentTUI(
                         self._append_run_elapsed_to_history(stop_reason=stop_reason)
                     self._run_start_time = None
                     self._set_busy(False)
-                    await self._status_bar.refresh()
+                    await self._refresh_status_bar_safely(reason="stop-event")
 
                     if waiting_for_input:
                         self._waiting_for_input = True

{comate_cli-0.8.4 → comate_cli-0.8.6}/comate_cli/terminal_agent/update_check.py

@@ -110,47 +110,12 @@ async def check_update(
     profiler: Any | None = None,
 ) -> UpdateInfo | None:
     """异步检查 comate-cli 是否有新版本，返回结构化版本信息或 None。"""
-    if profiler is not None:
-        profiler.mark("thread.await.start")
-    try:
-        return await asyncio.to_thread(
-            check_update_blocking,
-            package=package,
-            release_notes_url=release_notes_url,
-            log=log,
-            profiler=profiler,
-        )
-    except asyncio.CancelledError:
-        if profiler is not None:
-            profiler.mark("thread.await.cancelled")
-        raise
-    except Exception:
-        if profiler is not None:
-            profiler.mark("thread.await.failed")
-        active_logger = log or logger
-        active_logger.debug("update check worker failed", exc_info=True)
-        return None
-    finally:
-        if profiler is not None:
-            profiler.mark("thread.await.done")
-
-
-def check_update_blocking(
-    *,
-    package: str = PACKAGE_NAME,
-    release_notes_url: str = RELEASE_NOTES_URL,
-    log: logging.Logger | None = None,
-    profiler: Any | None = None,
-) -> UpdateInfo | None:
-    """同步执行版本检查；由 async wrapper 放入 worker thread，避免阻塞 TUI event loop。"""
     active_logger = log or logger
+    source_label = "unknown"
     try:
         if profiler is not None:
-            profiler.mark("thread.run.start")
-
+            profiler.mark("current_version.start")
         try:
-            if profiler is not None:
-                profiler.mark("current_version.start")
             current = importlib.metadata.version(package)
         except importlib.metadata.PackageNotFoundError:
             return None
@@ -170,74 +135,87 @@ def check_update_blocking(
             profiler.mark("locale.done")
 
         try:
-            if profiler is not None:
-                profiler.mark("httpx_import.start")
-            import httpx
-            if profiler is not None:
-                profiler.mark("httpx_import.done")
-
-            trust_env = _update_check_trust_env()
-            if profiler is not None:
-                profiler.mark(
-                    "http_client.trust_env.enabled"
-                    if trust_env
-                    else "http_client.trust_env.disabled"
-                )
-                profiler.mark("http_client.construct.start")
-            client_kwargs: dict[str, Any] = {"timeout": 3.0, "trust_env": trust_env}
-            if not trust_env:
-                # 默认路径用 certifi context 绕开 Windows 证书库枚举（见 _get_update_check_ssl_context）。
-                # trust_env 逃生通道（企业代理/自签根证书）保持 httpx 默认 verify=True 行为不变。
-                ssl_context = _get_update_check_ssl_context()
-                if ssl_context is not None:
-                    client_kwargs["verify"] = ssl_context
-            client = httpx.Client(**client_kwargs)
-            if profiler is not None:
-                profiler.mark("http_client.construct.done")
-
-            if profiler is not None:
-                profiler.mark("http_client.enter.start")
-            with client:
-                if profiler is not None:
-                    profiler.mark("http_client.enter.done")
-                    profiler.mark("http_get.start")
-                resp = client.get(url)
-                resp.raise_for_status()
-                latest = resp.json()["info"]["version"]
-                if profiler is not None:
-                    profiler.mark("http_get.done")
+            latest = await _fetch_latest_version_async(
+                url,
+                trust_env=_update_check_trust_env(),
+                profiler=profiler,
+            )
+        except asyncio.CancelledError:
+            raise
         except Exception:
             if profiler is not None:
                 profiler.mark("http_client.failed")
-            active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
-            return None
+            raise
+    except asyncio.CancelledError:
+        raise
+    except Exception:
+        active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
+        return None
 
-        try:
-            if profiler is not None:
-                profiler.mark("version_compare.start")
-            from packaging.version import Version
-
-            if Version(latest) > Version(current):
-                return UpdateInfo(
-                    package=package,
-                    current_version=current,
-                    latest_version=latest,
-                    release_notes_url=release_notes_url,
-                )
-        except Exception:
-            active_logger.debug(
-                "update comparison failed (current=%s, latest=%s)",
-                current,
-                latest,
-                exc_info=True,
+    try:
+        if profiler is not None:
+            profiler.mark("version_compare.start")
+        from packaging.version import Version
+
+        if Version(latest) > Version(current):
+            return UpdateInfo(
+                package=package,
+                current_version=current,
+                latest_version=latest,
+                release_notes_url=release_notes_url,
             )
-        finally:
-            if profiler is not None:
-                profiler.mark("version_compare.done")
-        return None
+    except Exception:
+        active_logger.debug(
+            "update comparison failed (current=%s, latest=%s)",
+            current,
+            latest,
+            exc_info=True,
+        )
     finally:
         if profiler is not None:
-            profiler.mark("thread.run.done")
+            profiler.mark("version_compare.done")
+    return None
+
+
+async def _fetch_latest_version_async(
+    url: str,
+    *,
+    trust_env: bool,
+    profiler: Any | None,
+) -> str:
+    if profiler is not None:
+        profiler.mark("httpx_import.start")
+    import httpx
+    if profiler is not None:
+        profiler.mark("httpx_import.done")
+        profiler.mark(
+            "http_client.trust_env.enabled"
+            if trust_env
+            else "http_client.trust_env.disabled"
+        )
+        profiler.mark("http_client.construct.start")
+
+    client_kwargs: dict[str, Any] = {"timeout": 3.0, "trust_env": trust_env}
+    if not trust_env:
+        ssl_context = _get_update_check_ssl_context()
+        if ssl_context is not None:
+            client_kwargs["verify"] = ssl_context
+
+    client = httpx.AsyncClient(**client_kwargs)
+    if profiler is not None:
+        profiler.mark("http_client.construct.done")
+        profiler.mark("http_client.enter.start")
+
+    async with client:
+        if profiler is not None:
+            profiler.mark("http_client.enter.done")
+            profiler.mark("http_get.start")
+        resp = await client.get(url)
+        resp.raise_for_status()
+        latest = resp.json()["info"]["version"]
+        if profiler is not None:
+            profiler.mark("http_get.done")
+        return str(latest)
 
 
 def format_update_hint(info: UpdateInfo) -> str:

{comate_cli-0.8.4 → comate_cli-0.8.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.8.4"
+version = "0.8.6"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"
@@ -31,6 +31,7 @@ dependencies = [
     "curl-cffi==0.13.0",
     "requests==2.32.5",
     "concurrent-log-handler>=0.9.25",
+    "httpx>=0.28.1,<0.29.0",
 ]
 
 [project.urls]