cecli-dev 1.0.0rc6__tar.gz → 1.0.0rc8__tar.gz

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cecli-dev
-Version: 1.0.0rc6
+Version: 1.0.0rc8
 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.0.0rc6 → cecli_dev-1.0.0rc8}/benchmark/README.md

@@ -26,6 +26,13 @@ without any human review or supervision! The LLM could generate dangerous python
 that harms your system, like this: `import os; os.system("sudo rm -rf /")`.
 Running inside a docker container helps limit the damage that could be done.
 
+The current harness (`benchmark.py`) organizes the exercises as "Cats": each
+exercise carries `cat.yaml` metadata, enabling per-test selection and
+deterministic subsets (e.g. `--hash-re '^0'`) for spot-checking models. The
+canonical exercises source is
+[ErichBSchulz/cecli-cats](https://github.com/ErichBSchulz/cecli-cats), a
+Cats-formatted conversion of the polyglot benchmark.
+
 ## Usage
 
 There are 3 main tasks involved in benchmarking:
@@ -41,8 +48,8 @@ There are 3 main tasks involved in benchmarking:
 These steps only need to be done once.
 
 ```
-ORG=Aider-AI
-REPO=aider
+ORG=cecli-dev
+REPO=cecli
 # Clone the main repo
 git clone https://github.com/$ORG/$REPO.git
 
@@ -50,8 +57,9 @@ git clone https://github.com/$ORG/$REPO.git
 cd $REPO
 mkdir tmp.benchmarks
 
-# Clone the repo with the exercises
-git clone https://github.com/$ORG/polyglot-benchmark tmp.benchmarks/polyglot-benchmark
+# Clone the canonical exercises source for the Cats harness
+git clone https://github.com/ErichBSchulz/cecli-cats tmp.benchmarks/cecli-cats
+
 
 # Build the docker container
 ./benchmark/docker_build.sh
@@ -69,10 +77,10 @@ Launch the docker container and run the benchmark inside it:
 ./benchmark/docker.sh
 
 # Run the benchmark:
-./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py a-helpful-name-for-this-run --model gpt-3.5-turbo --edit-format whole --threads 10 --exercises-dir cecli-cats
 
 # Or with OpenRouter models (requires OPENROUTER_API_KEY environment variable):
-./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir polyglot-benchmark
+./benchmark/benchmark.py openrouter-run --model openrouter/deepseek/deepseek-r1:free --edit-format whole --threads 10 --exercises-dir cecli-cats
 ```
 
 The above will create a folder
@@ -156,6 +164,7 @@ Note the roadmap priorities:
 
 ## Limitations
 
+- `benchmark_classic.py` is deprecated (it predates the async Coder API).
 - These scripts are not intended for use by typical `cecli` end users.
 - Some of the old (?deprecated) tools are written as `bash` scripts, so it will be hard to use
   them on Windows.

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/__init__.py

@@ -1,6 +1,6 @@
 from packaging import version
 
-__version__ = "0.100.11.dev"
+__version__ = "0.100.14.dev"
 safe_version = __version__
 
 try:

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.0.0rc6'
-__version_tuple__ = version_tuple = (1, 0, 0, 'rc6')
+__version__ = version = '1.0.0rc8'
+__version_tuple__ = version_tuple = (1, 0, 0, 'rc8')
 
-__commit_id__ = commit_id = 'gddead555a'
+__commit_id__ = commit_id = 'g98591f5a3'

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/args.py

@@ -598,6 +598,12 @@ def get_parser(default_config_files, git_root):
         default=True,
         help="Enable/disable streaming responses (default: True)",
     )
+    group.add_argument(
+        "--spinner",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Enable/disable the spinner while waiting for LLM responses (default: True)",
+    )
     group.add_argument(
         "--user-input-color",
         default="#00cc00",

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/coders/agent_coder.py

@@ -315,6 +315,25 @@ class AgentCoder(Coder):
                 call_result = await litellm.experimental_mcp_client.call_openai_tool(
                     session=session, openai_tool=tool_call_dict
                 )
+            except Exception as e:
+                if server.is_session_expired_error(e):
+                    try:
+                        session = await server.reconnect()
+                        call_result = await litellm.experimental_mcp_client.call_openai_tool(
+                            session=session, openai_tool=tool_call_dict
+                        )
+                    except Exception as retry_exc:
+                        self.io.tool_warning(
+                            f"Executing {tool_name} on {server.name} failed after reconnect:\n"
+                            f"Error: {retry_exc}"
+                        )
+                        return f"Error executing tool call {tool_name}: {retry_exc}"
+                else:
+                    self.io.tool_warning(
+                        f"Executing {tool_name} on {server.name} failed:\nError: {e}"
+                    )
+                    return f"Error executing tool call {tool_name}: {e}"
+            try:
                 content_parts = []
                 if call_result.content:
                     for item in call_result.content:

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/coders/base_coder.py

@@ -221,6 +221,7 @@ class Coder(metaclass=UsageMeta):
     message_tokens_sent = 0
     message_tokens_received = 0
     message_cached_tokens = 0
+    message_cost_deferred = None
     add_cache_headers = False
     cache_warming_thread = None
     num_cache_warming_pings = 0
@@ -1497,6 +1498,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     await self.io.recreate_input()
                     await self.io.input_task
                     user_message = self.io.input_task.result()
@@ -1645,6 +1650,10 @@ class Coder(metaclass=UsageMeta):
                         self.show_announcements()
                     self.suppress_announcements_for_next_prompt = True
 
+                    if self.message_cost_deferred and not self.io.spinner_active:
+                        self.io.tool_output(self.message_cost_deferred)
+                        self.message_cost_deferred = None
+
                     # Stop spinner before showing announcements or getting input
                     self.io.stop_spinner()
                     self.copy_context()
@@ -2512,7 +2521,11 @@ class Coder(metaclass=UsageMeta):
             if not self.tui:
                 spinner_text += f" • ${self.format_cost(self.total_cost)} session"
 
-            self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            if self.io.spinner_active:
+                self.io.start_spinner(spinner_text, coder_uuid=getattr(self, "uuid", None))
+            else:
+                self.message_cost_deferred = spinner_text
+
             if self.stream:
                 self.mdstream = True
             else:
@@ -2635,6 +2648,10 @@ class Coder(metaclass=UsageMeta):
 
             # Ensure any waiting spinner is stopped
             self.io.start_spinner("Processing Answer...", coder_uuid=getattr(self, "uuid", None))
+
+            if not self.io.spinner_active:
+                self.partial_response_content = self.get_multi_response_content_in_progress(True)
+
             self.remove_reasoning_content()
             self.multi_response_content = ""
 
@@ -2980,12 +2997,22 @@ class Coder(metaclass=UsageMeta):
                             continue
 
                         async def do_tool_call():
+                            nonlocal session
                             from litellm import experimental_mcp_client
 
-                            return await experimental_mcp_client.call_openai_tool(
-                                session=session,
-                                openai_tool=new_tool_call,
-                            )
+                            try:
+                                return await experimental_mcp_client.call_openai_tool(
+                                    session=session,
+                                    openai_tool=new_tool_call,
+                                )
+                            except Exception as e:
+                                if server.is_session_expired_error(e):
+                                    session = await server.reconnect()
+                                    return await experimental_mcp_client.call_openai_tool(
+                                        session=session,
+                                        openai_tool=new_tool_call,
+                                    )
+                                raise
 
                         call_result, interrupted = await coroutines.interruptible(
                             do_tool_call(), self.interrupt_event

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/helpers/orchestration/environment.py

@@ -202,16 +202,30 @@ class AgentExecutionEnv:
     # Shared across all AgentExecutionEnv instances — any agent can read/write
     _shared_state: TrackedDict = TrackedDict()
 
-    def __init__(self, coder: Any) -> None:
+    def __init__(self, coder: Any, orchestration_config: dict[str, Any] | None = None) -> None:
+        from typing import Any as _Any
+
+        self._orchestration_config: dict[str, _Any] = orchestration_config or {}
+        self._DANGEROUS_BUILTINS: set[str] = {
+            "eval",
+            "exec",
+            "open",
+            "__import__",
+            "compile",
+            "breakpoint",
+            "globals",
+            "locals",
+        }
+
         self.state = TrackedDict()
         self.state._set_owner(self)
         self._shared_state._set_owner(self, is_shared=True)
 
         # Initialize early so _safe_builtins can reference them
-        self.globals: dict[str, Any] = {}
-        self.locals: dict[str, Any] = {}
+        self.globals: dict[str, _Any] = {}
+        self.locals: dict[str, _Any] = {}
 
-        self._safe_builtins: dict[str, Any] = {
+        self._safe_builtins: dict[str, _Any] = {
             "print": print,
             "range": range,
             "len": len,
@@ -267,6 +281,32 @@ class AgentExecutionEnv:
             "pathlib": _SafePathlib,
         }
 
+        # Task 3: allowed_builtins — extend _safe_builtins with user-requested builtins
+        allowed_builtins: list[str] = self._orchestration_config.get("allowed_builtins", [])
+        for name in allowed_builtins:
+            if name.startswith("_"):
+                raise ValueError(f"Cannot allow private builtin '{name}'")
+            if name in self._DANGEROUS_BUILTINS and not self._orchestration_config.get(
+                "disable_security"
+            ):
+                raise ValueError(f"Cannot allow dangerous builtin '{name}'")
+            self._safe_builtins[name] = __builtins__[name]
+
+        # When security is fully disabled, expose dangerous builtins
+        if self._orchestration_config.get("disable_security", False):
+            for name in self._DANGEROUS_BUILTINS:
+                self._safe_builtins[name] = __builtins__[name]
+
+        # When allow_classes is enabled, expose __build_class__ needed by Python
+        if self._orchestration_config.get("allow_classes", False):
+            self._safe_builtins["__build_class__"] = __builtins__["__build_class__"]
+
+        # When allowed_imports is configured, expose __import__ so imports work,
+        # and add __name__ since imported modules reference it.
+        if self._orchestration_config.get("allowed_imports"):
+            self._safe_builtins["__import__"] = __builtins__["__import__"]
+            self._safe_builtins["__name__"] = "__sandbox__"
+
         self.globals.clear()
         _agent = AgentProxy(coder)
         _agent._env = self
@@ -382,7 +422,8 @@ class AgentExecutionEnv:
 
         code_str = code_str.strip()
         code_str = _escape_newlines_in_strings(code_str)
-        code_str, extra_globals = _strip_allowed_imports(code_str)
+        extra_allowed = frozenset(self._orchestration_config.get("allowed_imports", []))
+        code_str, extra_globals = _strip_allowed_imports(code_str, extra_allowed=extra_allowed)
         self.globals.update(extra_globals)
         if not code_str:
             return {"results": "", "state_variables": self._state_snapshot()}
@@ -411,8 +452,13 @@ class AgentExecutionEnv:
             return {"results": code, "state_variables": self._state_snapshot()}
 
         try:
-            tree = SecurityFilter().visit(tree)
-            tree = LoopYieldInjector().visit(tree)
+            if not self._orchestration_config.get("disable_security", False):
+                tree = SecurityFilter(
+                    allowed_imports=extra_allowed,
+                    allow_classes=self._orchestration_config.get("allow_classes", False),
+                ).visit(tree)
+            if not self._orchestration_config.get("disable_loop_protection", False):
+                tree = LoopYieldInjector().visit(tree)
             ast.fix_missing_locations(tree)
         except SecurityError as e:
             return _build_result(f"Security Error: {e}")
@@ -477,7 +523,9 @@ def build_orchestration_context_block(agent_config: dict[str, Any]) -> str | Non
     if not agent_config.get("allow_orchestration", True):
         return None
 
-    return """<context name="orchestration" from="agent">
+    orchestration_config = agent_config.get("orchestration", {})
+
+    context = """<context name="orchestration" from="agent">
 The `Orchestrate` tool lets you batch multiple tool calls in a single step by writing Python code in a limited, secure sandbox.
 This is much more efficient than making individual tool calls for loop-heavy workflows.
 Variables and methods defined in a script are persisted in subsequent turns.
@@ -611,6 +659,28 @@ await Agent.edit_region(
 4. Use `print(...)` to output results — only printed output is returned
 </context>"""
 
+    # Task 6: Append sandbox configuration overrides when non-empty
+    if orchestration_config:
+        overrides: list[str] = []
+        if orchestration_config.get("allowed_imports"):
+            overrides.append(
+                f"- Allowed extra imports: {orchestration_config['allowed_imports']}"
+            )
+        if orchestration_config.get("allowed_builtins"):
+            overrides.append(
+                f"- Allowed extra builtins: {orchestration_config['allowed_builtins']}"
+            )
+        if orchestration_config.get("allow_classes"):
+            overrides.append("- Class definitions are allowed (__init__, __str__, etc.)")
+        if orchestration_config.get("disable_security"):
+            overrides.append("- ⚠ Security filtering is DISABLED")
+        if orchestration_config.get("disable_loop_protection"):
+            overrides.append("- ⚠ Loop protection is DISABLED")
+        if overrides:
+            context += "\n### Sandbox Configuration Overrides\n" + "\n".join(overrides) + "\n"
+
+    return context
+
 
 # flake8: noqa
 # fmt: on

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/helpers/orchestration/safe_methods.py

@@ -586,12 +586,21 @@ _PREIMPORTED_MODULES: frozenset[str] = frozenset(
 )
 
 
-def _strip_allowed_imports(code: str) -> tuple[str, dict[str, object]]:
+def _strip_allowed_imports(
+    code: str,
+    extra_allowed: frozenset[str] | None = None,
+) -> tuple[str, dict[str, object]]:
     """Strip import lines for modules already pre-imported in the sandbox.
 
     The sandbox provides ``re``, ``math``, ``itertools``, ``collections``,
     ``datetime``, ``traceback``, and ``json`` as read-only proxies.
 
+    When *extra_allowed* is provided, import statements for those modules
+    are also allowed through (neither stripped nor commented out).  The caller
+    is responsible for ensuring those names are resolvable at execution time
+    (either by pre-importing them into the sandbox globals or letting the
+    ``SecurityFilter`` allow the ``import`` statement through).
+
     Returns ``(code, extra_globals)`` where *extra_globals* maps imported
     names to their resolved values.  The caller must inject these into the
     execution namespace before running the code.
@@ -606,7 +615,11 @@ def _strip_allowed_imports(code: str) -> tuple[str, dict[str, object]]:
 
     import re as _re
 
+    preimported = _PREIMPORTED_MODULES
+    skip_allowed = extra_allowed or frozenset()
+
     lines = code.splitlines()
+
     result = []
     extra_globals: dict[str, object] = {}
 
@@ -619,7 +632,11 @@ def _strip_allowed_imports(code: str) -> tuple[str, dict[str, object]]:
             r"import\s+(\w+)(?:\s+as\s+(\w+))?\s*$",
             stripped,
         )
-        if m and m.group(1) in _PREIMPORTED_MODULES:
+        if m and m.group(1) in skip_allowed:
+            result.append(line)
+            continue
+
+        if m and m.group(1) in preimported:
             mod_name = m.group(1)
             alias = m.group(2) or mod_name
 
@@ -637,7 +654,11 @@ def _strip_allowed_imports(code: str) -> tuple[str, dict[str, object]]:
             r"from\s+(\w+)\s+import\s+(.*)$",
             stripped,
         )
-        if m and m.group(1) in _PREIMPORTED_MODULES:
+        if m and m.group(1) in skip_allowed:
+            result.append(line)
+            continue
+
+        if m and m.group(1) in preimported:
             mod_name = m.group(1)
             names_clause = m.group(2)
 

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/helpers/orchestration/security.py

@@ -59,6 +59,41 @@ class SecurityFilter(ast.NodeTransformer):
 
     _SAFE_DUNDER: set[str] = {"__name__", "__doc__"}
 
+    _SAFE_CLASS_DUNDERS: frozenset[str] = frozenset(
+        {
+            "__init__",
+            "__str__",
+            "__repr__",
+            "__iter__",
+            "__next__",
+            "__len__",
+            "__getitem__",
+            "__setitem__",
+            "__contains__",
+            "__enter__",
+            "__exit__",
+            "__aenter__",
+            "__aexit__",
+            "__await__",
+            "__anext__",
+            "__aiter__",
+            "__del__",
+            "__init_subclass__",
+            "__set_name__",
+            "__class_getitem__",
+        }
+    )
+
+    def __init__(
+        self,
+        allowed_imports: frozenset[str] | None = None,
+        allow_classes: bool = False,
+    ):
+        super().__init__()
+        self._allowed_imports = allowed_imports or frozenset()
+        self._allow_classes = allow_classes
+        self._class_depth = 0
+
     # ------------------------------------------------------------------
     # Helpers
     # ------------------------------------------------------------------
@@ -89,17 +124,24 @@ class SecurityFilter(ast.NodeTransformer):
     # Statement visitors (import / global / nonlocal)
     # ------------------------------------------------------------------
 
-    def visit_Import(self, node: ast.Import) -> ast.Expr:
-        return self._make_raise_stmt(
-            f"Security filter error at line {node.lineno}: "
-            "Imports are disabled in the agent orchestration environment."
-        )
+    def visit_Import(self, node: ast.Import) -> ast.Expr | ast.Import:
+        for alias in node.names:
+            if alias.name not in self._allowed_imports:
+                return self._make_raise_stmt(
+                    f"Security filter error at line {node.lineno}: "
+                    f"Import '{alias.name}' is not in allowed_imports."
+                )
 
-    def visit_ImportFrom(self, node: ast.ImportFrom) -> ast.Expr:
-        return self._make_raise_stmt(
-            f"Security filter error at line {node.lineno}: "
-            "Imports are disabled in the agent orchestration environment."
-        )
+        return node
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> ast.Expr | ast.ImportFrom:
+        if node.module is None or node.module not in self._allowed_imports:
+            return self._make_raise_stmt(
+                f"Security filter error at line {node.lineno}: "
+                f"Import from '{node.module}' is not in allowed_imports."
+            )
+
+        return node
 
     def visit_Global(self, node: ast.Global) -> ast.Expr:
         return self._make_raise_stmt(
@@ -114,17 +156,47 @@ class SecurityFilter(ast.NodeTransformer):
         )
 
     # ------------------------------------------------------------------
-    # Expression visitors (attribute access / dangerous calls)
+    def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef | ast.Expr:
+        if self._allow_classes:
+            self._class_depth += 1
+            self.generic_visit(node)
+            self._class_depth -= 1
+            return node
+
+        return self._make_raise_stmt(
+            f"Security filter error at line {node.lineno}: "
+            "Class definitions are disabled in the orchestration environment."
+        )
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef | ast.Expr:
+        if self._allow_classes and self._class_depth > 0 and node.name.startswith("__"):
+            if node.name not in self._SAFE_CLASS_DUNDERS:
+                return self._make_raise_stmt(
+                    f"Security filter error at line {node.lineno}: "
+                    f"Method name '{node.name}' is not allowed. "
+                    f"Only safe dunder methods are permitted inside class bodies."
+                )
+
+        return self.generic_visit(node)
+
     # ------------------------------------------------------------------
+    # Expression visitors (attribute access / dangerous calls)
 
     def visit_Attribute(self, node: ast.Attribute):
         if node.attr.startswith("_"):
             if node.attr in self._SAFE_DUNDER:
                 return self.generic_visit(node)
 
+            if (
+                self._allow_classes
+                and self._class_depth > 0
+                and node.attr in self._SAFE_CLASS_DUNDERS
+            ):
+                return self.generic_visit(node)
+
             if isinstance(node.ctx, (ast.Store, ast.Del)):
                 verb = "assign to" if isinstance(node.ctx, ast.Store) else "delete"
-                raise SecurityError(
+                return self._make_raise_expr(
                     f"Security filter error at line {node.lineno}: "
                     f"cannot {verb} private attribute '{node.attr}'"
                 )

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/helpers/orchestration/service.py

@@ -24,7 +24,11 @@ class OrchestrationService:
             cls._instances[coder] = instance
             return instance
 
-        instance = AgentExecutionEnv(coder)
+        orchestration_config = {}
+        if hasattr(coder, "agent_config"):
+            orchestration_config = coder.agent_config.get("orchestration", {})
+
+        instance = AgentExecutionEnv(coder, orchestration_config=orchestration_config)
         cls._instances[coder] = instance
         cls._uuid_index[coder.uuid] = instance
         return instance

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/interruptible_input.py

@@ -17,7 +17,14 @@ class InterruptibleInput:
             raise RuntimeError("InterruptibleInput is Unix-only (requires selectable stdin).")
 
         self._cancel = threading.Event()
-        self._sel = selectors.DefaultSelector()
+
+        # The default selector (Kqueue on macOS, Epoll on Linux) cannot
+        # handle pipe-based stdin (e.g. when running inside Emacs comint-mode).
+        # Fall back to SelectSelector which works with any fd that supports select().
+        if not sys.stdin.isatty():
+            self._sel = selectors.SelectSelector()
+        else:
+            self._sel = selectors.DefaultSelector()
 
         # self-pipe to wake up select() from interrupt()
         self._r, self._w = os.pipe()

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/io.py

@@ -368,6 +368,7 @@ class InputOutput:
         notifications_command=None,
         notification_bell=False,
         verbose=False,
+        show_spinner=True,
     ):
         self.console = Console()
         self.pretty = pretty
@@ -498,6 +499,7 @@ class InputOutput:
             fancy_input = False
 
         # Spinner state
+        self.spinner_active = show_spinner
         self.spinner_running = False
         self.spinner_text = ""
         self.last_spinner_text = ""
@@ -506,7 +508,7 @@ class InputOutput:
         self.spinner_last_frame_index = 0
         self.unicode_palette = "░█"
         self.fallback_spinner = None
-        self.fallback_spinner_enabled = True
+        self.fallback_spinner_enabled = show_spinner
 
         self.interruptible_input = None
 
@@ -568,7 +570,12 @@ class InputOutput:
         """Start the spinner."""
         self.stop_spinner()
 
+        if not self.spinner_active:
+            return
+
         if self.prompt_session:
+            if not self.fallback_spinner_enabled:
+                return
             self.spinner_running = True
             self.spinner_text = text
             self.spinner_frame_index = self.spinner_last_frame_index
@@ -581,9 +588,15 @@ class InputOutput:
             self.fallback_spinner.step()
 
     def update_spinner(self, text):
+        if not self.spinner_active:
+            return
+
         self.spinner_text = text
 
     def update_spinner_suffix(self, text=None):
+        if not self.spinner_active:
+            return
+
         if text:
             self.spinner_suffix = f" • {text[:16].strip()}"
         else:

{cecli_dev-1.0.0rc6 → cecli_dev-1.0.0rc8}/cecli/main.py

@@ -36,6 +36,20 @@ from dotenv import load_dotenv
 if sys.platform == "win32":
     if hasattr(asyncio, "set_event_loop_policy"):
         asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+elif sys.platform == "darwin":
+    # The default KqueueSelector cannot handle pipe-based stdin
+    # (e.g. when running inside Emacs comint-mode). Fall back to
+    # SelectSelector which works with any file descriptor that supports select().
+    import selectors
+
+    if not sys.stdin.isatty():
+        _original_event_loop_policy = asyncio.DefaultEventLoopPolicy
+
+        class _SelectSelectorPolicy(asyncio.DefaultEventLoopPolicy):
+            def new_event_loop(self):
+                return asyncio.SelectorEventLoop(selectors.SelectSelector())
+
+        asyncio.set_event_loop_policy(_SelectSelectorPolicy())
 
 from .dump import dump  # noqa
 
@@ -704,6 +718,7 @@ async def main_async(
             notifications_command=args.notifications_command,
             notification_bell=args.notification_bell,
             verbose=args.verbose,
+            show_spinner=args.spinner,
         )
 
     validate_tui_args(args)