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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.8.4
+Version: 0.8.5
 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.5}/comate_cli/terminal_agent/tui.py

@@ -1491,10 +1491,20 @@ 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:
+            await self._status_bar.refresh()
+        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 +1656,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 +1740,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.5}/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.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.8.4"
+version = "0.8.5"
 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]

{comate_cli-0.8.4 → comate_cli-0.8.5}/tests/test_app_startup_latency.py

@@ -4,7 +4,6 @@ import asyncio
 import json
 import subprocess
 import sys
-import threading
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
@@ -16,7 +15,6 @@ from comate_cli.terminal_agent.update_check import (
     UpdateInfo,
     UpdatePromptChoice,
     UpdatePromptDecision,
-    check_update,
 )
 
 _CLI_ROOT = Path(__file__).resolve().parents[1]
@@ -390,8 +388,8 @@ asyncio.run(main())
     async def test_pending_update_check_does_not_block_tui_run(self) -> None:
         session = _fake_session()
         created_tuis: list[_FakeTUI] = []
-        update_started = threading.Event()
-        release_update = threading.Event()
+        update_started = asyncio.Event()
+        release_update = asyncio.Event()
 
         class _RecordingTUI(_FakeTUI):
             def __init__(self, session, status_bar, renderer) -> None:
@@ -402,14 +400,14 @@ asyncio.run(main())
                 del mcp_init, profiler
                 self.run_called.set()
                 assert not update_started.is_set()
-                assert await asyncio.to_thread(update_started.wait, 0.2)
+                await asyncio.wait_for(update_started.wait(), timeout=0.2)
                 release_update.set()
                 await asyncio.sleep(0)
 
-        def _slow_blocking_check(**kwargs) -> UpdateInfo | None:
+        async def _slow_async_check(**kwargs) -> UpdateInfo | None:
             del kwargs
             update_started.set()
-            release_update.wait(timeout=1.0)
+            await asyncio.wait_for(release_update.wait(), timeout=1.0)
             return None
 
         try:
@@ -427,14 +425,10 @@ asyncio.run(main())
                     app_module,
                     "_import_update_check_core",
                     return_value=(
-                        check_update,
+                        _slow_async_check,
                         MagicMock(return_value=None),
                     ),
                 ),
-                patch(
-                    "comate_cli.terminal_agent.update_check.check_update_blocking",
-                    side_effect=_slow_blocking_check,
-                ),
                 patch.object(
                     app_module,
                     "_import_interactive_tui_components",

{comate_cli-0.8.4 → comate_cli-0.8.5}/tests/test_handle_error.py

@@ -8,7 +8,9 @@ from unittest.mock import AsyncMock, MagicMock
 
 def _make_tui_stub():
     """Create a minimal TUI stub with mocked dependencies."""
-    tui = MagicMock()
+    from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+    tui = TerminalAgentTUI.__new__(TerminalAgentTUI)
     tui._renderer = MagicMock()
     tui._animation_controller = AsyncMock()
     tui._status_bar = MagicMock()
@@ -16,6 +18,10 @@ def _make_tui_stub():
     tui._last_turn_user_preview = "some preview"
     tui._run_start_time = 12345.0
     tui._interrupt_requested_at = 67890.0
+    tui._allow_latest_recall_on_interrupt = True
+    tui._set_busy = MagicMock()
+    tui._append_run_elapsed_to_history = MagicMock()
+    tui._refresh_layers = MagicMock()
     return tui
 
 
@@ -108,6 +114,19 @@ class TestHandleError(unittest.TestCase):
 
         tui._refresh_layers.assert_called_once()
 
+    def test_handle_error_status_refresh_failure_does_not_escape(self):
+        from comate_cli.terminal_agent.tui import TerminalAgentTUI
+
+        tui = _make_tui_stub()
+        tui._status_bar.refresh = AsyncMock(side_effect=RuntimeError("refresh boom"))
+        exc = Exception("primary failure")
+
+        asyncio.run(TerminalAgentTUI._handle_error(tui, exc))
+
+        tui._renderer.append_system_message.assert_called_once()
+        tui._renderer.clear_auto_compacting.assert_called_once()
+        tui._refresh_layers.assert_called_once()
+
     def test_handle_error_warning_severity_for_rate_limit(self):
         """Rate limit errors should propagate warning severity to transient."""
         from comate_cli.terminal_agent.tui import TerminalAgentTUI

{comate_cli-0.8.4 → comate_cli-0.8.5}/tests/test_tui_provider_error_shield.py

@@ -21,14 +21,20 @@ from prompt_toolkit.output import DummyOutput
 
 from comate_agent_sdk.agent import Agent, AgentConfig
 from comate_agent_sdk.agent.chat_session import ChatSession
-from comate_agent_sdk.agent.events import StopEvent
+from comate_agent_sdk.agent.events import (
+    GoalUpdatedEvent,
+    ScheduledPromptFiredEvent,
+    StopEvent,
+)
 from comate_agent_sdk.llm.exceptions import ModelRateLimitError
 from comate_cli.terminal_agent.tui import TerminalAgentTUI
+from comate_cli.terminal_agent.tui_parts import UIMode
 
 
 class _RecordingRenderer:
     def __init__(self, *, release_on_system_message: asyncio.Event | None = None) -> None:
         self.system_messages: list[tuple[str, str]] = []
+        self.elapsed_messages: list[str] = []
         self.closed = False
         self._release_on_system_message = release_on_system_message
 
@@ -41,6 +47,9 @@ class _RecordingRenderer:
         if self._release_on_system_message is not None:
             self._release_on_system_message.set()
 
+    def append_elapsed_message(self, content: str) -> None:
+        self.elapsed_messages.append(content)
+
     def finalize_turn(self) -> None:
         pass
 
@@ -84,6 +93,46 @@ class _ProviderErrorSession:
         pass
 
 
+class _TwoScheduledTurnSession:
+    session_id = "s1"
+
+    def __init__(self) -> None:
+        self.run_controller = SimpleNamespace(clear=lambda: None)
+        self.runtime = SimpleNamespace(_mcp_manager=None)
+
+    async def events(self):
+        for index in range(2):
+            yield ScheduledPromptFiredEvent(
+                job_id=f"cron-{index}",
+                cron="* * * * *",
+                human_schedule="every 1 minutes",
+                recurring=True,
+                durable=False,
+                local_time="18:00",
+            )
+            yield StopEvent(reason="completed")
+
+
+class _GoalUpdatedThenScheduledTurnSession:
+    session_id = "s1"
+
+    def __init__(self) -> None:
+        self.run_controller = SimpleNamespace(clear=lambda: None)
+        self.runtime = SimpleNamespace(_mcp_manager=None)
+
+    async def events(self):
+        yield GoalUpdatedEvent(goal=None, reason="created")
+        yield ScheduledPromptFiredEvent(
+            job_id="cron-after-goal",
+            cron="* * * * *",
+            human_schedule="every 1 minutes",
+            recurring=True,
+            durable=False,
+            local_time="18:00",
+        )
+        yield StopEvent(reason="completed")
+
+
 class _ProviderErrorAfterCancelLLM:
     model = "fake-openai"
     provider = "openai"
@@ -223,6 +272,46 @@ def _template(llm: object, *, cwd: Path) -> Agent:
 
 
 class TestTUIProviderErrorShield(unittest.IsolatedAsyncioTestCase):
+    async def test_event_pump_continues_after_status_refresh_failure_during_scheduled_turn(
+        self,
+    ) -> None:
+        renderer = _RecordingRenderer()
+        tui = _make_tui_stub(
+            session=_TwoScheduledTurnSession(),  # type: ignore[arg-type]
+            renderer=renderer,
+        )
+        tui._busy = False
+        tui._ui_mode = UIMode.NORMAL
+        tui._status_bar.refresh = AsyncMock(
+            side_effect=[RuntimeError("refresh boom"), None]
+        )
+
+        await tui._consume_event_stream()
+
+        self.assertEqual(len(renderer.elapsed_messages), 2)
+        self.assertIn("Running scheduled task", renderer.elapsed_messages[0])
+        self.assertIn("Running scheduled task", renderer.elapsed_messages[1])
+
+    async def test_event_pump_continues_after_status_refresh_failure_during_goal_update(
+        self,
+    ) -> None:
+        renderer = _RecordingRenderer()
+        tui = _make_tui_stub(
+            session=_GoalUpdatedThenScheduledTurnSession(),  # type: ignore[arg-type]
+            renderer=renderer,
+        )
+        tui._busy = False
+        tui._ui_mode = UIMode.NORMAL
+        tui._invalidate = MagicMock()
+        tui._status_bar.refresh = AsyncMock(
+            side_effect=[RuntimeError("goal refresh boom"), None]
+        )
+
+        await tui._consume_event_stream()
+
+        self.assertEqual(len(renderer.elapsed_messages), 1)
+        self.assertIn("Running scheduled task", renderer.elapsed_messages[0])
+
     async def test_stop_event_provider_error_uses_project_error_display_path(self) -> None:
         exc = ModelRateLimitError("rate limited", model="fake:model")
         renderer = _RecordingRenderer()