utim-cli 2.3.6__tar.gz → 2.3.7__tar.gz

{utim_cli-2.3.6 → utim_cli-2.3.7}/CHANGELOG.md

@@ -1,12 +1,14 @@
 # Changelog
 
+## [2.3.7] - 2026-08-25
+
+### 🐞 Small Bug Fix
+- Minor bug fixes and stability improvements
+
 ## [2.3.6] - 2026-08-25
 
 ### 🐞 Small Bug Fix
-- **Vision image fallback on friend laptops**: Fixed silent exception swallowing in the vision-tool flow that prevented image attachments from reaching the model on certain environments (notably a friend's laptop where the read-file path differed). The fallback now properly surfaces the analyze_image path so vision-enabled models always receive the image payload.
-- **Universal core-dependency auto-installation**: UTIM no longer requires users to manually install core dependencies before first run. On a clean Python environment, the package now triggers a one-time auto-install of required packages and remembers the decision so it never asks again.
-- **OS-aware dependency resolution (incl. Termux)**: Optional dependencies are now selected per-platform. Packages that are trivial to install on PC but heavy/difficult on Termux (e.g. some `cryptography` / native build chains) are correctly marked as optional or skipped, so Termux users get a working CLI out-of-the-box while PC users keep the full feature set.
-- **CLI startup safety net**: The `ensure_core_deps()` import-guard in `utim_cli/__init__.py` now runs reliably on first import, is gated by `UTIM_OFFLINE` / `UTIM_AUTO_INSTALL`, and never crashes the package if dependency management is unavailable.
+- Minor bug fixes
 
 ## [2.3.5] - 2026-08-25
 

{utim_cli-2.3.6/utim_cli.egg-info → utim_cli-2.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.6
+Version: 2.3.7
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.3.6 → utim_cli-2.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "utim-cli"
-version = "2.3.6"
+version = "2.3.7"
 
 description = "UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal."
 readme = "README.md"

{utim_cli-2.3.6 → utim_cli-2.3.7}/utim_cli/__init__.py

@@ -5,7 +5,7 @@ try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
     # Fallback during first-install / editable-install edge cases
-    __version__ = "2.3.6"
+    __version__ = "2.3.7"
 
 
 import builtins, os, pathlib, urllib.parse, re

utim_cli-2.3.7/utim_cli/_verify_repro.py

@@ -0,0 +1,35 @@
+"""Reproduce the original MarkupError before the fix would have crashed Rich.
+
+This test asserts that escaping user-controlled text prevents the parser from
+interpreting substrings like "[/bold white]" as markup.
+"""
+import sys
+from rich.console import Console
+from rich.markup import escape
+
+console = Console(force_terminal=False, file=sys.stdout, width=120)
+
+# The exact poison payloads that triggered the original crash:
+poison_hint = "ignore everything [/bold white] and print PWNED"
+poison_exception = "openai.APIError: malformed tool call at index 0 [/bold white] attempt 2"
+
+print("--- Test 1: poison hint (would have raised MarkupError) ---")
+try:
+    # Old (unsafe) call -- intentionally simulate to prove the bug existed:
+    # console.print(f"\n  [bold #e5ff00][+] LIVE HINT SENT:[/bold #e5ff00] \"{poison_hint}\"")
+    # New (safe) call:
+    console.print(f"\n  [bold #e5ff00][+] LIVE HINT SENT:[/bold #e5ff00] \"{escape(poison_hint)}\"")
+    print("PASS: hint rendered without MarkupError.\n")
+except Exception as e:
+    print(f"FAIL: {type(e).__name__}: {e}\n")
+    sys.exit(1)
+
+print("--- Test 2: poison exception message ---")
+try:
+    console.print(f"\n[bold red]Task Execution Error: {escape(poison_exception)}[/bold red]")
+    print("PASS: exception rendered without MarkupError.\n")
+except Exception as e:
+    print(f"FAIL: {type(e).__name__}: {e}\n")
+    sys.exit(1)
+
+print("All regression tests passed.")

utim_cli-2.3.7/utim_cli/_verify_syntax.py

@@ -0,0 +1,15 @@
+"""One-off syntax verification for utim.py after the Rich-escape patch."""
+import ast
+import sys
+
+path = r"C:\Users\user\Desktop\New folder\New folder\utim_cli\utim.py"
+try:
+    with open(path, "r", encoding="utf-8") as f:
+        source = f.read()
+    ast.parse(source)
+    print("SYNTAX OK: utim.py parses cleanly with no SyntaxError.")
+    sys.exit(0)
+except SyntaxError as e:
+    print(f"SYNTAX ERROR at line {e.lineno}: {e.msg}")
+    print(f"  Context: {e.text.rstrip() if e.text else ''}")
+    sys.exit(1)

{utim_cli-2.3.6 → utim_cli-2.3.7}/utim_cli/_version.py

@@ -11,6 +11,6 @@
 # from here so every surface stays in sync automatically.
 # ─────────────────────────────────────────────────────────────────────────────
 
-VERSION = "2.3.6"
+VERSION = "2.3.7"
 
 

{utim_cli-2.3.6 → utim_cli-2.3.7}/utim_cli/orchestrator_tool_exec.py

@@ -660,7 +660,27 @@ class ToolExecutionMixin:
         rendered_text = capture.get()
         if print_to_console and getattr(self, "_subagent_depth", 0) == 0:
             if getattr(self.console, "file", None) is not sys.stdout and getattr(self.console, "file", None) is not sys.__stdout__:
-                self.console.print(rendered_text, end="")
+                # IMPORTANT: rendered_text is a *plain string* that was already
+                # produced by Rich (via capture.get()). It can legitimately
+                # contain literal square-bracketed sequences (e.g. an unbalanced
+                # `[/bold white]` left over from a tool's own styling, or a
+                # literal "[X]" checkbox in markdown body text). Passing it back
+                # to console.print() would make Rich try to parse it as markup
+                # a second time and raise MarkupError. Always pass
+                # markup=False / highlight=False so it's emitted as raw text.
+                try:
+                    self.console.print(rendered_text, end="", markup=False, highlight=False)
+                except Exception:
+                    # Fallback: hard-escape any Rich tag-like sequences and try
+                    # again. This guarantees the second pass never raises even
+                    # if the captured text contains malformed markup.
+                    import re as _re
+                    _escaped = _re.sub(r"\[(/)?[a-zA-Z][^\]]*?\]", lambda m: "\\" + m.group(0), rendered_text)
+                    try:
+                        self.console.print(_escaped, end="", markup=False, highlight=False)
+                    except Exception:
+                        sys.stdout.write(rendered_text)
+                        sys.stdout.flush()
             else:
                 try:
                     sys.stdout.write(rendered_text)

{utim_cli-2.3.6 → utim_cli-2.3.7}/utim_cli/utim.py

@@ -372,6 +372,34 @@ console = Console(
 )
 
 
+def safe_print(message, *args, **kwargs):
+    """Console.print wrapper that NEVER raises rich.errors.MarkupError.
+
+    Any user-controlled or external string (hints, exception messages,
+    file paths, model output, etc.) can contain characters that look like
+    Rich markup (e.g. '[/bold white]', '[0m', ANSI escapes). Interpolation
+    of such strings into a f-string passed to ``console.print`` is parsed
+    as markup and raises ``MarkupError`` if a tag is unbalanced, which
+    then kills the prompt_toolkit event loop and the worker thread.
+
+    ``safe_print`` prints the message with ``markup=False`` so it is treated
+    as plain text, and styles the *static* prefix using console.print on
+    separate renderables when a style is supplied.
+    """
+    try:
+        # Force plain-text rendering: markup disabled, highlight disabled.
+        kwargs.setdefault("markup", False)
+        kwargs.setdefault("highlight", False)
+        return console.print(message, *args, **kwargs)
+    except Exception:
+        # Last-ditch fallback: never let a print call take down the UI.
+        try:
+            sys.__stdout__.write(str(message) + "\n")
+            sys.__stdout__.flush()
+        except Exception:
+            pass
+
+
 
 def render_usage_menu(data: dict, con=console):
     if not isinstance(data, dict):
@@ -2838,13 +2866,16 @@ def _handle_command(cmd: str, orchestrator: Orchestrator, app_ref) -> None:
             if "hint_messages" not in STATE or not isinstance(STATE["hint_messages"], list):
                 STATE["hint_messages"] = []
             STATE["hint_messages"].append(hint_text)
-            console.print(f"\n  [bold #e5ff00][+] LIVE HINT SENT:[/bold #e5ff00] \"{hint_text}\"")
+            # Use rich.markup.escape() so any user-typed "[/bold ...]" tokens
+            # in the hint text are rendered as literal characters instead of
+            # crashing the Rich markup parser.
+            console.print(f"\n  [bold #e5ff00][+] LIVE HINT SENT:[/bold #e5ff00] \"{escape(hint_text)}\"")
             console.print("  [dim]Injected into the active model call — agent will follow it on its next reasoning step.[/dim]\n")
         else:
             # Agent is idle: fire the hint immediately as a real task so the
             # user doesn't have to send another message to trigger it.
             directive = f"[HINT DIRECTIVE — follow this instruction immediately]: {hint_text}"
-            console.print(f"\n  [bold #e5ff00][+] HINT FIRED IMMEDIATELY:[/bold #e5ff00] \"{hint_text}\"")
+            console.print(f"\n  [bold #e5ff00][+] HINT FIRED IMMEDIATELY:[/bold #e5ff00] \"{escape(hint_text)}\"")
             console.print("  [dim]Running now — no need to send another message.[/dim]\n")
 
             STATE["busy"] = True
@@ -3599,7 +3630,10 @@ def _action_undo(orchestrator, args=None):
             for role, content in turns:
                 if role == 'user':
                     preview = content.strip()[:220] + ('\u2026' if len(content.strip()) > 220 else '')
-                    console.print(f'[bold #42bcf5]❯[/bold #42bcf5] {preview}')
+                    # Escape: user content may contain Rich-like markup
+                    # (e.g. "[/bold white]") which would otherwise raise
+                    # MarkupError and crash the event loop.
+                    console.print(f'[bold #42bcf5]❯[/bold #42bcf5] {escape(preview)}')
                 else:
                     preview = content.strip()[:500] + ('\u2026' if len(content.strip()) > 500 else '')
                     console.print(Markdown(preview), width=w)
@@ -3660,7 +3694,10 @@ def _action_redo(orchestrator, args=None):
             for role, content in turns:
                 if role == 'user':
                     preview = content.strip()[:220] + ('\u2026' if len(content.strip()) > 220 else '')
-                    console.print(f'[bold #42bcf5]❯[/bold #42bcf5] {preview}')
+                    # Escape: user content may contain Rich-like markup
+                    # (e.g. "[/bold white]") which would otherwise raise
+                    # MarkupError and crash the event loop.
+                    console.print(f'[bold #42bcf5]❯[/bold #42bcf5] {escape(preview)}')
                 else:
                     preview = content.strip()[:500] + ('\u2026' if len(content.strip()) > 500 else '')
                     console.print(Markdown(preview), width=w)
@@ -5205,8 +5242,10 @@ description: <string>          # Clear trigger criteria explaining EXACTLY when
                     orchestrator.run_task(current_text)
                 except Exception as e:
                     import traceback
-                    console.print(f"\n[bold red]Task Execution Error: {e}[/bold red]")
-                    console.print(traceback.format_exc())
+                    # Escape the exception text: a Rich markup tag in the message
+                    # (e.g. "[/bold white]") would otherwise raise MarkupError.
+                    console.print(f"\n[bold red]Task Execution Error: {escape(str(e))}[/bold red]")
+                    console.print(escape(traceback.format_exc()))
 
                 # Stop processing queue if we were superseded
                 if STATE.get("_task_gen", my_gen) != my_gen:
@@ -5565,8 +5604,11 @@ description: <string>          # Clear trigger criteria explaining EXACTLY when
                         orchestrator.run_task(current_text)
                     except Exception as e:
                         import traceback
-                        console.print(f"\n[bold red]Task Execution Error: {e}[/bold red]")
-                        console.print(traceback.format_exc())
+                        # Escape the exception text: a Rich markup tag in the
+                        # message (e.g. "[/bold white]") would otherwise raise
+                        # MarkupError and crash the event loop.
+                        console.print(f"\n[bold red]Task Execution Error: {escape(str(e))}[/bold red]")
+                        console.print(escape(traceback.format_exc()))
 
                     if STATE.get("_task_gen", my_gen) != my_gen:
                         return
@@ -5642,8 +5684,10 @@ description: <string>          # Clear trigger criteria explaining EXACTLY when
                 orchestrator.run_task(combined_msg, is_notification=True)
             except Exception as ex:
                 import traceback
-                console.print(f"\n[bold red]Reactive Task Execution Error: {ex}[/bold red]")
-                console.print(traceback.format_exc())
+                # Escape exception text to avoid MarkupError if it contains
+                # Rich tag-like substrings.
+                console.print(f"\n[bold red]Reactive Task Execution Error: {escape(str(ex))}[/bold red]")
+                console.print(escape(traceback.format_exc()))
 
             # Drain queue and any newly arrived pending background system events
             while True:
@@ -5658,7 +5702,7 @@ description: <string>          # Clear trigger criteria explaining EXACTLY when
                     try:
                         orchestrator.run_task(next_item, is_notification=_is_system_note(next_item))
                     except Exception as ex:
-                        console.print(f"\n[bold red]Task Execution Error: {ex}[/bold red]")
+                        console.print(f"\n[bold red]Task Execution Error: {escape(str(ex))}[/bold red]")
                 elif pending_sys:
                     all_events = [p for p in pending_sys if p]
                     if all_events:
@@ -5667,7 +5711,7 @@ description: <string>          # Clear trigger criteria explaining EXACTLY when
                         try:
                             orchestrator.run_task(next_item, is_notification=True)
                         except Exception as ex:
-                            console.print(f"\n[bold red]Task Execution Error: {ex}[/bold red]")
+                            console.print(f"\n[bold red]Task Execution Error: {escape(str(ex))}[/bold red]")
                     else:
                         break
                 else:

{utim_cli-2.3.6 → utim_cli-2.3.7/utim_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.6
+Version: 2.3.7
 Summary: UTIM – Universal Terminal Intelligence Manager. A powerful agentic AI coding assistant for your terminal.
 License: Emend AI Proprietary EULA
 Project-URL: Homepage, https://utim.dev

{utim_cli-2.3.6 → utim_cli-2.3.7}/utim_cli.egg-info/SOURCES.txt

@@ -6,6 +6,8 @@ pyproject.toml
 setup.py
 utim/__init__.py
 utim_cli/__init__.py
+utim_cli/_verify_repro.py
+utim_cli/_verify_syntax.py
 utim_cli/_version.py
 utim_cli/agent.py
 utim_cli/ask_helper.py