cecli-dev 1.6.0rc1__tar.gz → 1.6.0rc2__tar.gz

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.6.0rc1
+Version: 1.6.0rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.6.0rc1'
-__version_tuple__ = version_tuple = (1, 6, 0, 'rc1')
+__version__ = version = '1.6.0rc2'
+__version_tuple__ = version_tuple = (1, 6, 0, 'rc2')
 
-__commit_id__ = commit_id = 'g42b3f06cf'
+__commit_id__ = commit_id = 'g24cf3948a'

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/helpers/coroutines.py

@@ -117,14 +117,19 @@ def task_is_cancelling() -> bool:
     Used to tell a genuine cancellation of the caller apart from cancellation
     errors that transports (e.g. MCP's anyio TaskGroups) surface for ordinary
     connection failures.
+
+    Reliable on Python 3.11+ (``Task.cancelling()``). On 3.10 there is no public
+    signal: ``_must_cancel`` is already cleared by the time the CancelledError is
+    delivered, so this is best-effort and usually reports False. Callers must
+    therefore treat False as "not known to be cancelling" rather than proof.
     """
     task = asyncio.current_task()
     if task is None:
         return False
 
-    cancelling = getattr(task, "cancelling", None)
-    if cancelling is not None:
-        return cancelling() > 0
+    cancelling_fn = getattr(task, "cancelling", None)
+    if cancelling_fn is not None:
+        return cancelling_fn() > 0
 
-    # Python 3.10 has no Task.cancelling(); fall back to the private flag.
+    # Python 3.10 fallback: best-effort only (see docstring).
     return bool(getattr(task, "_must_cancel", False))

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/mcp/manager.py

@@ -4,6 +4,10 @@ from cecli.helpers.coroutines import task_is_cancelling
 from cecli.mcp.server import DEFAULT_MCP_REQUEST_TIMEOUT, LocalServer, McpServer
 from cecli.tools.utils.registry import ToolRegistry
 
+# Slack added on top of a server's request timeout for the connect/list_tools
+# backstop, covering time the transport spends outside the SDK's read timeout.
+CONNECT_BACKSTOP_GRACE_SECONDS = 5
+
 
 class McpServerManager:
     """
@@ -204,7 +208,8 @@ class McpServerManager:
         # When io is None (e.g., during from_servers before IO is assigned),
         # _log_warning and _log_error silently return — retries still happen
         # but with no user-visible feedback. This is intentional.
-        max_retries = 3 if server.name != "unnamed-server" else 1
+        is_unnamed = server.name == "unnamed-server"
+        max_retries = 1 if is_unnamed else 3
         delay = 1.0
         backoff = 2.0
         max_delay = 30.0
@@ -219,10 +224,9 @@ class McpServerManager:
         if base_timeout <= 0:
             base_timeout = DEFAULT_MCP_REQUEST_TIMEOUT
 
-        attempt_timeout = base_timeout + 5
+        attempt_timeout = base_timeout + CONNECT_BACKSTOP_GRACE_SECONDS
 
         for attempt in range(1, max_retries + 1):
-            error = None
 
             try:
                 session = await asyncio.wait_for(server.connect(), timeout=attempt_timeout)
@@ -239,7 +243,7 @@ class McpServerManager:
             except Exception as e:
                 error = e
 
-            if attempt < max_retries and server.name != "unnamed-server":
+            if attempt < max_retries:
                 self._log_warning(
                     f"Connection attempt {attempt} failed for {name}, "
                     f"retrying in {delay}s... ({error})"
@@ -247,7 +251,7 @@ class McpServerManager:
                 await asyncio.sleep(delay)
                 delay = min(delay * backoff, max_delay)
             else:
-                if server.name != "unnamed-server":
+                if not is_unnamed:
                     self._log_error(
                         f"Failed to connect to MCP server {name} "
                         f"after {max_retries} attempts: {error}"

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/mcp/oauth.py

@@ -14,6 +14,10 @@ from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
 
 from cecli.decoding import safe_open
 
+# How long ``ensure_started`` waits for the callback listener to bind before
+# giving up so the browser redirect can't race the listener coming up.
+CALLBACK_BIND_TIMEOUT_SECONDS = 5
+
 
 def create_oauth_callback_server(port, path="/callback") -> Tuple[
     Callable[[], Awaitable[Tuple[str, str]]],
@@ -35,7 +39,6 @@ def create_oauth_callback_server(port, path="/callback") -> Tuple[
     server_error = None
     callback_received = threading.Event()
     server = None
-    server_thread = None
     server_started = threading.Event()
     start_lock = threading.Lock()
 
@@ -100,27 +103,19 @@ def create_oauth_callback_server(port, path="/callback") -> Tuple[
             server_started.set()
             callback_received.set()
         finally:
-            if srv is not None:
-                try:
-                    srv.server_close()
-                except Exception:
-                    pass
+            _close_quietly(srv)
 
     def ensure_started():
         """Start the callback listener once, blocking briefly for the bind."""
-        nonlocal server_thread
         with start_lock:
             if server_started.is_set():
                 return
 
-            server_thread = threading.Thread(
-                target=start_server, daemon=True, name="oauth-callback-server"
-            )
-            server_thread.start()
+            threading.Thread(target=start_server, daemon=True, name="oauth-callback-server").start()
 
         # Wait for the bind to complete so the browser redirect cannot race the
         # listener coming up.
-        server_started.wait(timeout=5)
+        server_started.wait(timeout=CALLBACK_BIND_TIMEOUT_SECONDS)
 
     def shutdown():
         """Stop the callback listener. Idempotent and safe to call repeatedly.
@@ -142,10 +137,7 @@ def create_oauth_callback_server(port, path="/callback") -> Tuple[
         except Exception:
             pass
         finally:
-            try:
-                srv.server_close()
-            except Exception:
-                pass
+            _close_quietly(srv)
 
     async def get_auth_code() -> Tuple[str, str]:
         # Backstop for callers that didn't start the listener via the redirect
@@ -278,3 +270,14 @@ class FileBasedTokenStorage(TokenStorage):
 
         all_tokens[self.server_name]["client_info"] = json.loads(client_info.model_dump_json())
         save_mcp_oauth_tokens(all_tokens)
+
+
+def _close_quietly(server) -> None:
+    """Close an HTTP server socket, ignoring a missing server or close errors."""
+    if server is None:
+        return
+
+    try:
+        server.server_close()
+    except Exception:
+        pass

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/mcp/server.py

@@ -251,15 +251,7 @@ class McpServer:
                 stdio_client(server_params, errlog=err_file)
             )
             read, write = stdio_transport
-            session = await self.exit_stack.enter_async_context(
-                ClientSession(
-                    read,
-                    write,
-                    read_timeout_seconds=timedelta(seconds=self._request_timeout_seconds()),
-                )
-            )
-            await session.initialize()
-            self.session = session
+            session = await self._enter_client_session(read, write)
 
         return session
 
@@ -334,6 +326,25 @@ class McpServer:
                 self.session = None
                 self._connection_loop = None
 
+    async def _enter_client_session(self, read, write):
+        """Enter a client session on the shared exit stack and initialize it.
+
+        Builds the SDK ``ClientSession`` with the server's configured request
+        timeout so the stdio and HTTP transports share identical timeout
+        behavior, then stores the initialized session on ``self.session``.
+        """
+        session = await self.exit_stack.enter_async_context(
+            ClientSession(
+                read,
+                write,
+                read_timeout_seconds=timedelta(seconds=self._request_timeout_seconds()),
+            )
+        )
+        await session.initialize()
+        self.session = session
+
+        return session
+
     def _request_timeout_seconds(self) -> float:
         """Per-request timeout (seconds) for the MCP handshake and tool calls.
 
@@ -474,15 +485,7 @@ class HttpBasedMcpServer(McpServer):
 
         read, write = _unpack_transport(transport)
 
-        session = await self.exit_stack.enter_async_context(
-            ClientSession(
-                read,
-                write,
-                read_timeout_seconds=timedelta(seconds=self._request_timeout_seconds()),
-            )
-        )
-        await session.initialize()
-        self.session = session
+        session = await self._enter_client_session(read, write)
 
         await self.start_keepalive()
 

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli/tui/worker.py

@@ -62,11 +62,7 @@ class CoderWorker:
         try:
             self.loop.run_until_complete(self._async_run())
         except BaseException as e:
-            # A normal stop() stops the loop, which makes run_until_complete
-            # raise RuntimeError; that and a cancellation after running=False
-            # are expected shutdown paths, not crashes.
-            graceful = not self.running and isinstance(e, (asyncio.CancelledError, RuntimeError))
-            if not graceful:
+            if not self._is_graceful_shutdown(e):
                 logger.error("Coder worker thread stopped unexpectedly", exc_info=e)
                 self._notify_crash(e)
         finally:
@@ -298,6 +294,15 @@ class CoderWorker:
         if self.thread and self.thread.is_alive():
             self.thread.join(timeout=2.0)
 
+    def _is_graceful_shutdown(self, exc) -> bool:
+        """Return True when a worker-loop exception is an expected shutdown artifact.
+
+        A normal stop() stops the loop, which surfaces from run_until_complete
+        as RuntimeError; a cancellation after running goes False surfaces as
+        CancelledError. Neither is a crash.
+        """
+        return not self.running and isinstance(exc, (asyncio.CancelledError, RuntimeError))
+
     def _notify_crash(self, exc):
         """Tell the TUI the worker died so it can surface the error and exit.
 

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.6.0rc1
+Version: 1.6.0rc2
 Summary: we also can't pronounce cecli
 Project-URL: Homepage, https://github.com/dwash96/cecli
 Project-URL: Documentation, https://github.com/dwash96/cecli

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/cecli_dev.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "1.6.0rc1",
+  "tag": "1.6.0rc2",
   "distance": 0,
-  "node": "g42b3f06cfec2f81b7ba56e18226f0f3e1cb346ab",
+  "node": "g24cf3948ae71e006992888d9d547edd9588c417f",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-09-15"

{cecli_dev-1.6.0rc1 → cecli_dev-1.6.0rc2}/tests/mcp/test_manager_retry.py

@@ -15,6 +15,7 @@ Test categories:
 """
 
 import asyncio
+import sys
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, patch
 
@@ -346,6 +347,14 @@ async def test_connect_server_treats_transport_cancellation_as_failure(mock_serv
 # ---------------------------------------------------------------------------
 
 
+# Python 3.10 cannot tell a real cancellation from a transport-level one: it has no
+# Task.cancelling(), _must_cancel is already cleared when the handler runs, and the
+# traceback loses the origin frame. task_is_cancelling() therefore reports False
+# there, so this propagation guarantee only holds on 3.11+.
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="Task.cancelling() is required to distinguish a real cancel from a transport cancel",
+)
 @pytest.mark.asyncio
 async def test_connect_server_propagates_genuine_cancellation(mock_server, mock_io):
     """TC-008b: cancelling the calling task still propagates out of connect_server."""