comate-cli 0.7.5__tar.gz → 0.7.6__tar.gz

{comate_cli-0.7.5 → comate_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: comate-cli
-Version: 0.7.5
+Version: 0.7.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

{comate_cli-0.7.5 → comate_cli-0.7.6}/comate_cli/terminal_agent/app.py

@@ -42,6 +42,7 @@ from comate_cli.terminal_agent.update_check import (
 
 console = Console()
 logger = logging.getLogger(__name__)
+_UPDATE_CHECK_DELAY_S = 1.0
 
 
 def _resolve_cli_project_root() -> Path:
@@ -69,7 +70,7 @@ async def _handle_update_on_launch(info: UpdateInfo) -> bool:
         if decision == UpdatePromptDecision.SKIP:
             return False
         if decision == UpdatePromptDecision.SHOW_HINT:
-            console.print(format_update_hint(info))
+            console.print(f"[dim]{format_update_hint(info)}[/]")
             mark_update_seen(info)
             return False
 
@@ -115,6 +116,9 @@ def _schedule_update_check_on_launch(
     async def _run() -> None:
         try:
             profiler.mark("update_check.start")
+            profiler.mark("update_check.delay.start")
+            await asyncio.sleep(_UPDATE_CHECK_DELAY_S)
+            profiler.mark("update_check.delay.done")
             update_info = await _check_update(profiler=profiler.child("update_check"))
             profiler.mark("update_check.done")
             if update_info is not None:

{comate_cli-0.7.5 → comate_cli-0.7.6}/comate_cli/terminal_agent/startup_profile.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 import os
+import threading
 import time
 
 
@@ -17,12 +18,14 @@ class StartupProfiler:
         started_at: float | None = None,
         prefix: str = "",
         pending_messages: list[str] | None = None,
+        lock: threading.Lock | None = None,
     ) -> None:
         self._logger = logger
         self._enabled = enabled
         self._started_at = started_at if started_at is not None else time.perf_counter()
         self._prefix = prefix.strip(".")
         self._pending_messages = pending_messages if pending_messages is not None else []
+        self._lock = lock if lock is not None else threading.Lock()
 
     @classmethod
     def from_env(cls, *, logger: logging.Logger) -> "StartupProfiler":
@@ -37,20 +40,30 @@ class StartupProfiler:
         if self._prefix:
             normalized_phase = f"{self._prefix}.{normalized_phase}"
         elapsed_ms = (time.perf_counter() - self._started_at) * 1000
-        self._pending_messages.append(
-            f"startup_profile phase={normalized_phase} elapsed_ms={elapsed_ms:.3f}"
-        )
-        self.flush()
+        with self._lock:
+            self._pending_messages.append(
+                f"startup_profile phase={normalized_phase} elapsed_ms={elapsed_ms:.3f}"
+            )
+            pending = self._drain_pending_locked()
+        for message in pending:
+            self._logger.info(message)
 
     def flush(self) -> None:
-        if not self._enabled or not self._pending_messages:
+        if not self._enabled:
             return
+        with self._lock:
+            pending = self._drain_pending_locked()
+        for message in pending:
+            self._logger.info(message)
+
+    def _drain_pending_locked(self) -> list[str]:
+        if not self._pending_messages:
+            return []
         if not self._logger.isEnabledFor(logging.INFO):
-            return
+            return []
         pending = list(self._pending_messages)
         self._pending_messages.clear()
-        for message in pending:
-            self._logger.info(message)
+        return pending
 
     def child(self, prefix: str) -> "StartupProfiler":
         normalized_prefix = prefix.strip(".")
@@ -64,4 +77,5 @@ class StartupProfiler:
             started_at=self._started_at,
             prefix=normalized_prefix,
             pending_messages=self._pending_messages,
+            lock=self._lock,
         )

{comate_cli-0.7.5 → comate_cli-0.7.6}/comate_cli/terminal_agent/update_check.py

@@ -24,6 +24,8 @@ PACKAGE_NAME = "comate-cli"
 RELEASE_NOTES_URL = "https://github.com/AndyLee1024/agent-sdk/releases/latest"
 UPDATE_COMMAND = ("uv", "tool", "update", PACKAGE_NAME)
 _SETTINGS_SECTION = "updates"
+_UPDATE_CHECK_TRUST_ENV = "COMATE_CLI_UPDATE_CHECK_TRUST_ENV"
+_TRUTHY_ENV_VALUES = {"1", "true", "yes", "on"}
 
 
 class UpdatePromptDecision(Enum):
@@ -65,6 +67,11 @@ def _is_chinese_locale() -> bool:
     return False
 
 
+def _update_check_trust_env() -> bool:
+    raw = os.environ.get(_UPDATE_CHECK_TRUST_ENV, "")
+    return raw.strip().lower() in _TRUTHY_ENV_VALUES
+
+
 async def check_update(
     *,
     package: str = PACKAGE_NAME,
@@ -73,77 +80,136 @@ async def check_update(
     profiler: Any | None = None,
 ) -> UpdateInfo | None:
     """异步检查 comate-cli 是否有新版本，返回结构化版本信息或 None。"""
-    active_logger = log or logger
+    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("current_version.start")
-        current = importlib.metadata.version(package)
-    except importlib.metadata.PackageNotFoundError:
+            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("current_version.done")
+            profiler.mark("thread.await.done")
 
-    if profiler is not None:
-        profiler.mark("locale.start")
-    if _is_chinese_locale():
-        url = f"https://mirrors.tuna.tsinghua.edu.cn/pypi/{package}/json"
-        source_label = "tuna"
-    else:
-        url = f"https://pypi.org/pypi/{package}/json"
-        source_label = "pypi"
-    if profiler is not None:
-        profiler.mark("locale.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
     try:
         if profiler is not None:
-            profiler.mark("httpx_import.start")
-        import httpx
-        if profiler is not None:
-            profiler.mark("httpx_import.done")
+            profiler.mark("thread.run.start")
 
-        async with httpx.AsyncClient(timeout=3.0) as client:
+        try:
             if profiler is not None:
-                profiler.mark("http_get.start")
-            resp = await client.get(url)
-            resp.raise_for_status()
-            latest = resp.json()["info"]["version"]
+                profiler.mark("current_version.start")
+            current = importlib.metadata.version(package)
+        except importlib.metadata.PackageNotFoundError:
+            return None
+        finally:
             if profiler is not None:
-                profiler.mark("http_get.done")
-    except Exception:
-        active_logger.debug(f"update check failed (source={source_label})", exc_info=True)
-        return None
+                profiler.mark("current_version.done")
 
-    try:
         if profiler is not None:
-            profiler.mark("version_compare.start")
-        from packaging.version import Version
+            profiler.mark("locale.start")
+        if _is_chinese_locale():
+            url = f"https://mirrors.tuna.tsinghua.edu.cn/pypi/{package}/json"
+            source_label = "tuna"
+        else:
+            url = f"https://pypi.org/pypi/{package}/json"
+            source_label = "pypi"
+        if profiler is not None:
+            profiler.mark("locale.done")
 
-        if Version(latest) > Version(current):
-            return UpdateInfo(
-                package=package,
-                current_version=current,
-                latest_version=latest,
-                release_notes_url=release_notes_url,
+        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 = httpx.Client(timeout=3.0, trust_env=trust_env)
+            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")
+        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
+
+        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,
             )
-    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("version_compare.done")
+        return None
     finally:
         if profiler is not None:
-            profiler.mark("version_compare.done")
-    return None
+            profiler.mark("thread.run.done")
 
 
 def format_update_hint(info: UpdateInfo) -> str:
+    # Returns plain text only. Callers are responsible for adding markup
+    # appropriate to their render target (Rich Console vs prompt_toolkit).
     return (
-        f"[dim] New version available: [bold cyan]{info.latest_version}[/] "
+        f"New version available: {info.latest_version} "
         f"(current: {info.current_version})  "
-        f"Run [bold green]uv tool update {info.package}[/] to update.[/]"
+        f"Run `uv tool update {info.package}` to update."
     )
 
 

{comate_cli-0.7.5 → comate_cli-0.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "comate-cli"
-version = "0.7.5"
+version = "0.7.6"
 description = "Comate terminal CLI built on comate-agent-sdk"
 readme = "README.md"
 requires-python = ">=3.11,<3.14"

{comate_cli-0.7.5 → comate_cli-0.7.6}/tests/test_app_startup_latency.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import threading
 import unittest
 from pathlib import Path
 from types import SimpleNamespace
@@ -140,8 +141,8 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
     async def test_pending_update_check_does_not_block_tui_run(self) -> None:
         session = _fake_session()
         created_tuis: list[_FakeTUI] = []
-        update_started = asyncio.Event()
-        update_cancelled = asyncio.Event()
+        update_started = threading.Event()
+        release_update = threading.Event()
 
         class _RecordingTUI(_FakeTUI):
             def __init__(self, session, status_bar, renderer) -> None:
@@ -150,41 +151,48 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
 
             async def run(self, *, mcp_init, profiler=None) -> None:
                 del mcp_init, profiler
-                await asyncio.wait_for(update_started.wait(), timeout=0.1)
                 self.run_called.set()
+                assert not update_started.is_set()
+                assert await asyncio.to_thread(update_started.wait, 0.2)
+                release_update.set()
+                await asyncio.sleep(0)
 
-        async def _never_finishes(*, profiler=None) -> UpdateInfo | None:
-            del profiler
+        def _slow_blocking_check(**kwargs) -> UpdateInfo | None:
+            del kwargs
             update_started.set()
-            try:
-                await asyncio.Event().wait()
-                return None
-            finally:
-                update_cancelled.set()
-
-        with (
-            patch.object(app_module, "_resolve_cli_project_root", return_value=Path("/tmp/project")),
-            patch.object(
-                app_module,
-                "run_preflight_if_needed",
-                AsyncMock(return_value=PreflightResult(status="configured")),
-            ),
-            patch.object(app_module, "_build_agent", return_value=object()),
-            patch.object(app_module, "print_logo"),
-            patch.object(app_module, "_check_update", side_effect=_never_finishes),
-            patch.object(app_module, "EventRenderer", return_value=MagicMock()),
-            patch("comate_cli.terminal_agent.logging_adapter.setup_tui_logging", return_value=MagicMock()),
-            patch.object(app_module, "_resolve_session", return_value=(session, "new")),
-            patch.object(app_module, "StatusBar", _FakeStatusBar),
-            patch.object(app_module, "TerminalAgentTUI", _RecordingTUI),
-            patch.object(app_module, "_graceful_shutdown", AsyncMock()),
-            patch.object(app_module, "_format_exit_usage_line", return_value=None),
-        ):
-            await asyncio.wait_for(app_module.run(), timeout=0.2)
+            release_update.wait(timeout=1.0)
+            return None
+
+        try:
+            with (
+                patch.object(app_module, "_UPDATE_CHECK_DELAY_S", 0.01),
+                patch.object(app_module, "_resolve_cli_project_root", return_value=Path("/tmp/project")),
+                patch.object(
+                    app_module,
+                    "run_preflight_if_needed",
+                    AsyncMock(return_value=PreflightResult(status="configured")),
+                ),
+                patch.object(app_module, "_build_agent", return_value=object()),
+                patch.object(app_module, "print_logo"),
+                patch(
+                    "comate_cli.terminal_agent.update_check.check_update_blocking",
+                    side_effect=_slow_blocking_check,
+                ),
+                patch.object(app_module, "EventRenderer", return_value=MagicMock()),
+                patch("comate_cli.terminal_agent.logging_adapter.setup_tui_logging", return_value=MagicMock()),
+                patch.object(app_module, "_resolve_session", return_value=(session, "new")),
+                patch.object(app_module, "StatusBar", _FakeStatusBar),
+                patch.object(app_module, "TerminalAgentTUI", _RecordingTUI),
+                patch.object(app_module, "_graceful_shutdown", AsyncMock()),
+                patch.object(app_module, "_format_exit_usage_line", return_value=None),
+            ):
+                await asyncio.wait_for(app_module.run(), timeout=0.4)
+        finally:
+            release_update.set()
 
         self.assertEqual(len(created_tuis), 1)
         self.assertTrue(created_tuis[0].run_called.is_set())
-        self.assertTrue(update_cancelled.is_set())
+        self.assertTrue(update_started.is_set())
 
     async def test_update_check_exception_does_not_block_tui_run(self) -> None:
         session = _fake_session()
@@ -232,6 +240,7 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
         )
 
         with (
+            patch.object(app_module, "_UPDATE_CHECK_DELAY_S", 0.01),
             patch.object(app_module, "_check_update", AsyncMock(return_value=info)),
             patch.object(app_module, "decide_update_prompt", return_value=UpdatePromptDecision.SHOW_HINT),
             patch.object(app_module, "mark_update_seen") as mark_seen,
@@ -256,6 +265,7 @@ class TestAppStartupLatency(unittest.IsolatedAsyncioTestCase):
         )
 
         with (
+            patch.object(app_module, "_UPDATE_CHECK_DELAY_S", 0.01),
             patch.object(app_module, "_check_update", AsyncMock(return_value=info)),
             patch.object(app_module, "decide_update_prompt", return_value=UpdatePromptDecision.SHOW_PROMPT),
             patch.object(app_module, "show_update_prompt", AsyncMock()) as show_prompt,

{comate_cli-0.7.5 → comate_cli-0.7.6}/tests/test_startup_profile.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-import logging
 import asyncio
+import logging
+import threading
 import unittest
 from contextlib import contextmanager
 from pathlib import Path
@@ -129,6 +130,104 @@ class TestStartupProfiler(unittest.TestCase):
         self.assertIn("phase=agent.build.start", messages[0])
         self.assertIn("phase=logging.setup.done", messages[1])
 
+    def test_flush_releases_buffered_marks_after_info_logging_is_enabled(self) -> None:
+        logger = logging.getLogger("comate_cli.tests.startup_profile.flush")
+        original_level = logger.level
+        original_propagate = logger.propagate
+        records: list[logging.LogRecord] = []
+
+        class _ListHandler(logging.Handler):
+            def emit(self, record: logging.LogRecord) -> None:
+                records.append(record)
+
+        handler = _ListHandler(level=logging.INFO)
+        logger.handlers[:] = []
+        logger.addHandler(handler)
+        logger.propagate = False
+        logger.setLevel(logging.WARNING)
+
+        try:
+            with (
+                patch.dict("os.environ", {"COMATE_STARTUP_PROFILE": "1"}, clear=False),
+                patch("comate_cli.terminal_agent.startup_profile.time.perf_counter", side_effect=[3.0, 3.01]),
+            ):
+                profiler = StartupProfiler.from_env(logger=logger)
+                profiler.mark("pre_logging.phase")
+
+                self.assertEqual(records, [])
+
+                logger.setLevel(logging.INFO)
+                profiler.flush()
+
+            messages = [record.getMessage() for record in records]
+        finally:
+            logger.removeHandler(handler)
+            logger.setLevel(original_level)
+            logger.propagate = original_propagate
+
+        self.assertEqual(len(messages), 1)
+        self.assertIn("phase=pre_logging.phase", messages[0])
+
+    def test_child_profiler_shares_thread_lock(self) -> None:
+        logger = MagicMock(spec=logging.Logger)
+
+        with patch.dict("os.environ", {"COMATE_STARTUP_PROFILE": "1"}, clear=False):
+            profiler = StartupProfiler.from_env(logger=logger)
+
+        child = profiler.child("worker")
+
+        self.assertIs(child._lock, profiler._lock)
+
+    def test_child_marks_from_threads_do_not_drop_phases(self) -> None:
+        logger = logging.getLogger("comate_cli.tests.startup_profile.threaded")
+        original_level = logger.level
+        original_propagate = logger.propagate
+        records: list[logging.LogRecord] = []
+        records_lock = threading.Lock()
+
+        class _ListHandler(logging.Handler):
+            def emit(self, record: logging.LogRecord) -> None:
+                with records_lock:
+                    records.append(record)
+
+        handler = _ListHandler(level=logging.INFO)
+        logger.handlers[:] = []
+        logger.addHandler(handler)
+        logger.propagate = False
+        logger.setLevel(logging.INFO)
+
+        try:
+            with patch.dict("os.environ", {"COMATE_STARTUP_PROFILE": "1"}, clear=False):
+                profiler = StartupProfiler.from_env(logger=logger)
+
+            def _mark(prefix: str, count: int) -> None:
+                child = profiler.child(prefix)
+                for index in range(count):
+                    child.mark(f"phase{index}")
+
+            threads = [
+                threading.Thread(target=_mark, args=("worker_a", 20)),
+                threading.Thread(target=_mark, args=("worker_b", 20)),
+            ]
+            for thread in threads:
+                thread.start()
+            for thread in threads:
+                thread.join()
+
+            messages = [record.getMessage() for record in records]
+        finally:
+            logger.removeHandler(handler)
+            logger.setLevel(original_level)
+            logger.propagate = original_propagate
+
+        self.assertEqual(len(messages), 40)
+        for prefix in ("worker_a", "worker_b"):
+            for index in range(20):
+                self.assertTrue(
+                    any(f"phase={prefix}.phase{index}" in message for message in messages),
+                    f"missing {prefix}.phase{index}: {messages}",
+                )
+
 
 class TestStartupProfilerTUI(unittest.IsolatedAsyncioTestCase):
     async def test_tui_run_marks_run_async_boundary(self) -> None: