utim-cli 2.3.19__tar.gz → 2.3.20__tar.gz

{utim_cli-2.3.19 → utim_cli-2.3.20}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [2.3.20] - 2026-09-04
+
+### 🛠️ Minor Fixes and Enhancement
+- Minor fixes and enhancement
+
 ## [2.3.19] - 2026-09-02
 
 ### 🛠️ Model Dialog Tier Sync & Free Model Preservation

{utim_cli-2.3.19/utim_cli.egg-info → utim_cli-2.3.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: utim-cli
-Version: 2.3.19
+Version: 2.3.20
 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.19 → utim_cli-2.3.20}/pyproject.toml

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

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim/__init__.py

@@ -14,7 +14,7 @@ Quickstart:
 try:
     from utim_cli._version import VERSION as __version__
 except ImportError:
-    __version__ = "2.3.19"
+    __version__ = "2.3.20"
 
 # Developer-friendly core classes (similar to `import genai` / `import openai`)
 from utim_cli.sdk.session import UtimSession as Session

{utim_cli-2.3.19 → utim_cli-2.3.20}/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.19"
+    __version__ = "2.3.20"
 
 
 import builtins, os, pathlib, urllib.parse, re

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/_version.py

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

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/auth.py

@@ -497,7 +497,7 @@ def login(restart: bool = False) -> None:
             config.set("uid", body.get("user_id", ""))
             config.set("name", body.get("display_name") or (body.get("email", "") or "").split("@")[0])
             plan_name = body.get("plan")
-            if not plan_name and body.get("api_key"):
+            if (not plan_name or plan_name == "free") and body.get("api_key"):
                 try:
                     _vr = requests.get(
                         f"{SERVER_URL}/api/user-plan",
@@ -505,10 +505,12 @@ def login(restart: bool = False) -> None:
                         timeout=3.0,
                     )
                     if _vr.status_code == 200:
-                        plan_name = (_vr.json() or {}).get("plan")
+                        _pdata = _vr.json() or {}
+                        plan_name = _pdata.get("plan") or _pdata.get("plan_name")
                 except Exception:
                     pass
-            config.set("user_plan", (plan_name or "free").lower())
+            clean_plan = str(plan_name or "free").lower().removesuffix(" plan").strip()
+            config.set("user_plan", clean_plan)
             if body.get("api_key"):
                 config.set("api_key", body["api_key"])
             raw_print("")

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/client_utils.py

@@ -64,6 +64,44 @@ def get_server_url() -> str:
     return "https://api.utim.dev"
 
 
+def is_paid_plan(plan_name: Optional[str]) -> bool:
+    """Return True if the given plan name represents a paid subscription tier."""
+    if not plan_name:
+        return False
+    p = str(plan_name).lower().removesuffix(" plan").strip()
+    return p not in ("free", "free tier", "", "none", "null", "guest", "undefined")
+
+
+def is_user_paid(force_refresh: bool = False) -> bool:
+    """Helper to check if the current user has an active paid subscription tier."""
+    try:
+        from utim_cli.config import config
+        api_key = config.get("api_key")
+        cached_plan = config.get("user_plan")
+
+        if not force_refresh and cached_plan and is_paid_plan(cached_plan):
+            return True
+
+        if not api_key:
+            return is_paid_plan(cached_plan)
+
+        try:
+            from utim_cli.orchestrator_helpers import get_cached_quota
+            quota = get_cached_quota(api_key, force_refresh=force_refresh)
+            if quota:
+                plan = quota.get("plan") or quota.get("plan_name")
+                if plan:
+                    clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                    config.set("user_plan", clean_plan)
+                    return is_paid_plan(clean_plan)
+        except Exception:
+            pass
+
+        return is_paid_plan(cached_plan)
+    except Exception:
+        return False
+
+
 def _sanitize_json(obj):
     """Recursively scrub a payload for values that break strict JSON parsers.
 
@@ -1026,10 +1064,19 @@ def repair_and_normalize_tool_call(tc: dict) -> dict:
     raw_name = str(fn.get("name", "")).strip()
     raw_args = fn.get("arguments", "{}")
 
-    # 1. Clean and normalize tool name
+    raw_name_orig = raw_name
     for known in KNOWN_TOOLS:
         if raw_name.startswith(known):
+            remainder = raw_name[len(known):].strip()
             raw_name = known
+            if remainder and (not str(raw_args).strip() or str(raw_args).strip() == "{}"):
+                attrs = re.findall(r'(\w+)\s*=\s*(?:"((?:[^"\\]|\\.)*)"|\'((?:[^\'\\]|\\.)*)\'|(\S+))', remainder)
+                if attrs:
+                    parsed_attrs = {}
+                    for _k, _v1, _v2, _v3 in attrs:
+                        _v = _v1 or _v2 or _v3 or ""
+                        parsed_attrs[_k] = _v
+                    raw_args = parsed_attrs
             break
         if raw_name == known + known:
             raw_name = known

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/orchestrator.py

@@ -594,6 +594,30 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
             except Exception:
                 pass
 
+            # ── Sanitize: strip base64-encoded binary blobs ─────────────────
+            # On Termux, copying an image file can place raw base64 data into the
+            # clipboard.  If any paste-chip expansion path leaks this binary noise
+            # into the user message, we detect and truncate it here before it
+            # reaches the model context.
+            _B64_RUN_RE = re.compile(r'[A-Za-z0-9+/=]{400,}')
+            if _B64_RUN_RE.search(user_message):
+                # Count total base64-characters vs meaningful content
+                b64_chars = sum(1 for c in user_message if 'A' <= c <= 'Z' or 'a' <= c <= 'z' or '0' <= c <= '9' or c in '+/=')
+                total_chars = max(len(user_message), 1)
+                if total_chars > 600 and (b64_chars / total_chars) > 0.85:
+                    # The message is dominated by binary noise — keep only
+                    # non-base64 lines and any embedded file paths.
+                    clean_lines = []
+                    for line in user_message.split('\n'):
+                        line_stripped = line.strip()
+                        b64_ratio = sum(1 for c in line_stripped if 'A' <= c <= 'Z' or 'a' <= c <= 'z' or '0' <= c <= '9' or c in '+/=') / max(len(line_stripped), 1)
+                        # Keep lines that are paths or have low base64 ratio
+                        if b64_ratio < 0.70 or re.search(r'[A-Za-z]:[\\/]|/[^\s]+\.\w{2,4}', line_stripped):
+                            clean_lines.append(line)
+                    if clean_lines:
+                        user_message = '\n'.join(clean_lines)
+                        user_message += f"\n\n[Pasted binary clipboard data stripped — {total_chars} chars of base64 noise removed]"
+
             # Auto-detect image paths in user_message and send direct multimodal vision payload
             try:
                 img_matches = re.findall(r'(?:[A-Za-z]:[\\/][^\s"\']+\.(?:png|jpg|jpeg|webp|gif)|/[^\s"\']+\.(?:png|jpg|jpeg|webp|gif))', user_message, re.IGNORECASE)
@@ -829,6 +853,17 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
 
                     break  # success
                 except _ServerUnavailableError as exc:
+                    _err_text = str(exc).lower()
+                    if "rate limit" in _err_text or "rate-limit" in _err_text or "429" in _err_text or "too many requests" in _err_text:
+                        self.console.print(f"\n[bold yellow]⏳  Model is temporarily rate-limited by the provider.[/bold yellow]")
+                        self.console.print("  [dim]Please wait a moment before retrying, or switch models using [bold]/model[/bold] (Ctrl+M).[/dim]\n")
+                        if len(self.messages) <= turn_msg_start + 1:
+                            self.messages.append({
+                                "role": "assistant",
+                                "content": "⏳ **Model Rate Limited**: The model is temporarily rate-limited by the provider. Please wait a short moment and retry, or use `/model` to switch models."
+                            })
+                        self._persist_messages()
+                        return
                     if self.cancel_event.is_set():
                         del self.messages[turn_msg_start + 1:]
                         self._persist_messages()
@@ -875,6 +910,17 @@ class Orchestrator(LLMTransportMixin, TurnHistoryMixin, ToolExecutionMixin):
                         self.messages.append({"role": "assistant", "content": "[Aborted by user]"})
                     break
                 except Exception as exc:
+                    _err_text = str(exc).lower()
+                    if "rate limit" in _err_text or "rate-limit" in _err_text or "429" in _err_text or "too many requests" in _err_text:
+                        self.console.print(f"\n[bold yellow]⏳  Model is temporarily rate-limited by the provider.[/bold yellow]")
+                        self.console.print("  [dim]Please wait a moment before retrying, or switch models using [bold]/model[/bold] (Ctrl+M).[/dim]\n")
+                        if len(self.messages) <= turn_msg_start + 1:
+                            self.messages.append({
+                                "role": "assistant",
+                                "content": "⏳ **Model Rate Limited**: The model is temporarily rate-limited by the provider. Please wait a short moment and retry, or use `/model` to switch models."
+                            })
+                        self._persist_messages()
+                        return
                     if self.cancel_event.is_set():
                         if len(self.messages) <= turn_msg_start + 1:
                             self.messages.append({"role": "assistant", "content": "[Aborted by user]"})

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/orchestrator_helpers.py

@@ -244,7 +244,13 @@ def get_cached_quota(api_key: str, force_refresh: bool = False) -> Optional[Dict
                 session = get_http_session()
                 resp = session.get(f"{SERVER_URL}/quota", headers={"X-API-Key": api_key}, timeout=2.0)
                 if resp.status_code == 200:
-                    _QUOTA_CACHE.update({"data": resp.json(), "timestamp": time.time(), "api_key": api_key})
+                    data = resp.json()
+                    _QUOTA_CACHE.update({"data": data, "timestamp": time.time(), "api_key": api_key})
+                    plan = data.get("plan") or data.get("plan_name")
+                    if plan:
+                        from utim_cli.config import config
+                        clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                        config.set("user_plan", clean_plan)
             except Exception:
                 pass
         threading.Thread(target=_bg_quota_refresh, daemon=True).start()
@@ -263,6 +269,11 @@ def get_cached_quota(api_key: str, force_refresh: bool = False) -> Optional[Dict
             data = resp.json()
             _QUOTA_CACHE.clear()
             _QUOTA_CACHE.update({"data": data, "timestamp": now, "api_key": api_key})
+            plan = data.get("plan") or data.get("plan_name")
+            if plan:
+                from utim_cli.config import config
+                clean_plan = str(plan).lower().removesuffix(" plan").strip()
+                config.set("user_plan", clean_plan)
             return data
     except Exception:
         pass

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/orchestrator_llm_transport.py

@@ -133,6 +133,11 @@ Contains: _get_configured_model_source, _is_custom_model_selection,
 _resolve_model_endpoint, _call_llm. Behavior-identical; Orchestrator inherits.
 """
 class LLMTransportMixin:
+    _PRE_THINK_PATTERNS = re.compile(
+        r"^\s*(\*\s*Thinking\.\.\.?|\.\.\.(\s*thinking)?|thinking\.\.\.?)\s*$",
+        re.IGNORECASE | re.MULTILINE,
+    )
+
     def _get_configured_model_source(self, model_id: str, *, is_primary: bool = False) -> Optional[str]:
         """Return the selected source for a model id when the picker recorded one."""
         if is_primary:
@@ -736,7 +741,9 @@ class LLMTransportMixin:
                     # 1. Check if quota is exhausted (only for non-custom models)
                     is_5h_exhausted = bool(quota.get("five_hour_quota_exhausted", False))
                     is_monthly_exhausted = bool(quota.get("is_exhausted", False))
-                    is_exhausted = is_5h_exhausted or is_monthly_exhausted
+                    bonus_bal = float(quota.get("bonus_balance", quota.get("free_bonus_balance", 0.0)) or 0.0)
+                    # If the user has available bonus credits, inference is funded by bonus quota
+                    is_exhausted = (is_5h_exhausted or is_monthly_exhausted) and bonus_bal <= 0.0
 
                     if not is_custom and is_exhausted:
                         reset_raw = quota.get("five_hour_reset_at") if is_5h_exhausted else (quota.get("reset_at") or quota.get("five_hour_reset_at", ""))
@@ -771,7 +778,7 @@ class LLMTransportMixin:
                         
                     # 2. Check if chosen model is allowed — skip entirely for BYOK/custom models
                     models_allowed = quota.get("models_allowed", [])
-                    free_bonus_balance = quota.get("free_bonus_balance", 0.0) or 0.0
+                    free_bonus_balance = float(quota.get("bonus_balance", quota.get("free_bonus_balance", 0.0)) or 0.0)
                     chosen_model = override_model if override_model else self.model_id
                     is_custom = self._is_custom_model_selection(chosen_model, is_primary=not override_model)
                     is_free_user = (quota.get("plan") == "free" or str(quota.get("display_name", "")).lower() == "free")
@@ -802,18 +809,8 @@ class LLMTransportMixin:
                                     self.model_source = "utim"
                                     config.set("main_model_source", "utim")
                         else:
-                            # Paid plan (plan != free): gate APINEX models
-                            if is_apinex:
-                                fallback_model = "anthropic/claude-3-5-sonnet-20241022"
-                                self.console.print(f"\n[bold yellow]APINEX model '{chosen_model}' is exclusively for the Free plan.[/bold yellow]")
-                                self.console.print(f"  Switching to your plan's model: '{fallback_model}'.\n")
-                                if override_model:
-                                    override_model = fallback_model
-                                else:
-                                    self.model_id = fallback_model
-                                    self.model_source = "utim"
-                                    config.set("main_model_source", "utim")
-                            elif models_allowed != ["all"] and chosen_model not in models_allowed and free_bonus_balance <= 0.0:
+                            # Paid plan: APINEX models are free gateway models — allowed on every plan
+                            if models_allowed != ["all"] and chosen_model not in models_allowed and not is_apinex and free_bonus_balance <= 0.0:
                                 fallback_model = DEFAULT_MODEL
                                 self.console.print(f"\n[bold yellow]Model '{chosen_model}' is gated under your current '{quota.get('display_name', 'Free')}' plan.[/bold yellow]")
                                 self.console.print(f"  Downgrading to default allowed model: '{fallback_model}' for this request.")
@@ -1314,8 +1311,10 @@ class LLMTransportMixin:
                                 # NOTE: last_content_time is updated further below, only when
                                 # actual content or tool-call data is parsed from the chunk.
                                     
-                                # Clean and normalize the raw line
-                                line_str = raw_line.strip()
+                                if isinstance(raw_line, bytes):
+                                    line_str = raw_line.decode("utf-8", errors="ignore").strip()
+                                else:
+                                    line_str = str(raw_line).strip()
                                 if not line_str:
                                     continue
 
@@ -1356,10 +1355,15 @@ class LLMTransportMixin:
                                     if t == "queue_status":
                                         pos = chunk.get("position", 1)
                                         status = chunk.get("status", "queued")
+                                        tier = chunk.get("tier", "")
+                                        prio = chunk.get("priority", 0)
                                         if status == "queued":
                                             try:
                                                 from utim_cli.state import STATE
-                                                STATE["thinking_topic"] = f"Request Queued Position {pos}"
+                                                if prio > 0 and tier:
+                                                    STATE["thinking_topic"] = f"Request Queued Position {pos} ({str(tier).title()} Priority)"
+                                                else:
+                                                    STATE["thinking_topic"] = f"Request Queued Position {pos}"
                                             except Exception:
                                                 pass
                                         elif status == "processing":
@@ -1522,12 +1526,23 @@ class LLMTransportMixin:
                                                     "tool_calls": None,
                                                 }, False
                                             elif _is_rate_limit:
+                                                rate_limit_display = (
+                                                    f"⏳ **Model Rate Limited**: `{current_model}` is currently experiencing high demand and is temporarily rate-limited by the provider.\n\n"
+                                                    f"- **What to do:** Please wait a moment before retrying, or switch to a different model with `/model` or `Ctrl+M`.\n"
+                                                    f"- **Retry:** You can resend your prompt anytime."
+                                                )
                                                 if not silent:
                                                     self.console.print(
-                                                        f"\n[dim yellow]↪ {_friendly_name} is currently rate-limited — "
-                                                        f"switching to the next available model…[/dim yellow]"
+                                                        f"\n[bold yellow]⏳  Model '{current_model}' is temporarily rate-limited by the provider.[/bold yellow]"
                                                     )
-                                                raise RuntimeError(f"__RATE_LIMITED__:{current_model}")
+                                                    self.console.print(
+                                                        "  [dim]Please wait a moment before retrying, or switch models using [bold]/model[/bold] (Ctrl+M).[/dim]\n"
+                                                    )
+                                                return {
+                                                    "role": "assistant",
+                                                    "content": rate_limit_display,
+                                                    "tool_calls": None,
+                                                }, False
                                             elif _is_provider_upstream:
                                                 if not silent:
                                                     self.console.print(
@@ -1948,7 +1963,8 @@ class LLMTransportMixin:
                                 timeout=5,
                             )
                             if _qr.status_code == 200:
-                                _has_bonus = (_qr.json().get("free_bonus_balance") or 0.0) > 0.0
+                                _data = _qr.json()
+                                _has_bonus = (float(_data.get("bonus_balance", _data.get("free_bonus_balance", 0.0)) or 0.0) > 0.0)
                         except Exception:
                             pass
                         if _has_bonus:
@@ -2067,124 +2083,23 @@ class LLMTransportMixin:
                                 "tool_calls": None,
                             }, False
 
-                        if not msg_str:
-                            msg_str = "Provider is temporarily rate-limiting this model."
-
-                        # Stash the original message so the final-exhaustion branch can use it
-                        _rate_limit_detail = msg_str
-                        _rate_limit_upgrade_url = upgrade_url
-
-                        # Are there more models in the fallback chain to try?
-                        _has_more_models = model_idx < len(models_to_try) - 1
-
-                        if _has_more_models:
-                            # Soft, dim notice — let the next model in the chain take over.
-                            # The user doesn't need to (and shouldn't) see provider jargon.
-                            try:
-                                self.console.print(
-                                    f"\n[dim yellow]↪ {current_model} is busy right now — "
-                                    f"switching to the next available model…[/dim yellow]"
-                                )
-                            except Exception:
-                                pass
-                            # Break the inner retry loop → outer loop will pick the next model
-                            last_exc = exc
-                            break
-                        else:
-                            # Last model in chain also rate-limited — show a CLEAN, friendly
-                            # banner. Mask raw OpenRouter jargon. If the model name looks
-                            # like a free/OpenRouter endpoint, frame it as "all free
-                            # models are momentarily busy" instead of a paid-upgrade CTA.
-                            _is_free_tier_model = (
-                                ":free" in current_model
-                                or "/free" in current_model
-                                or "openrouter" in current_model.lower()
-                            )
-                            _display_msg = _rate_limit_detail
-                            # Strip provider-specific keywords that leak through to users
-                            import re as _re
-                            for _jargon in (
-                                "tokens per minute", "requests per minute",
-                                "free model", "free tier", "provider",
-                            ):
-                                _display_msg = _re.sub(
-                                    _re.escape(_jargon),
-                                    "",
-                                    _display_msg,
-                                    flags=_re.IGNORECASE,
-                                )
-                            # Word-boundary stripping for short tokens (tpm, rpm)
-                            for _jargon in ("tpm", "rpm"):
-                                _display_msg = _re.sub(
-                                    rf"\b{_jargon}\b",
-                                    "",
-                                    _display_msg,
-                                    flags=_re.IGNORECASE,
-                                )
-                            # Collapse leftover whitespace + dangling punctuation
-                            _display_msg = _re.sub(r"\s+", " ", _display_msg).strip(" .,;:—-")
-                            # Drop the generic "returned error:" prefix — it's provider
-                            # boilerplate that adds no value to a human reader.
-                            _display_msg = _re.sub(
-                                r"^(?:returned error|error)\s*[:\-—]?\s*",
-                                "",
-                                _display_msg,
-                                flags=_re.IGNORECASE,
-                            ).strip(" .,;:—-")
-                            # If the sanitized message is too short or doesn't really say
-                            # anything useful, swap in a polished default.
-                            _low = _display_msg.lower()
-                            # Count substantive words (>= 3 chars, alpha) to detect
-                            # sentences that were gutted by jargon stripping.
-                            _substantive = sum(
-                                1 for _w in _re.findall(r"[A-Za-z]{3,}", _display_msg)
-                            )
-                            # Detect a "stranded period" artifact: a period that's now
-                            # surrounded by whitespace because its surrounding words
-                            # were stripped. This is a strong signal that the message
-                            # was gutted by jargon removal and is no longer readable.
-                            _has_stranded_period = bool(_re.search(r"\s\.\s", _display_msg))
-                            _is_uninformative = (
-                                len(_display_msg) < 12
-                                or _substantive < 3
-                                or _has_stranded_period
-                                or _low in ("returned error", "error", "rate limit", "limit")
-                                or _low in ("", ".", "..", "...")
-                            )
-                            if _is_uninformative:
-                                if _is_free_tier_model:
-                                    _display_msg = (
-                                        "All free models are momentarily busy. "
-                                        "This clears automatically within a minute or two."
-                                    )
-                                else:
-                                    _display_msg = "Rate limit reached for this model."
-
+                        rate_limit_display = (
+                            f"⏳ **Model Rate Limited**: `{current_model}` is currently experiencing high demand and is temporarily rate-limited by the provider.\n\n"
+                            f"- **What to do:** Please wait a moment before retrying, or switch to a different model with `/model` or `Ctrl+M`.\n"
+                            f"- **Retry:** You can resend your prompt anytime."
+                        )
+                        if not silent:
                             self.console.print(
-                                f"\n[bold yellow]⏳  {_display_msg}[/bold yellow]"
+                                f"\n[bold yellow]⏳  Model '{current_model}' is temporarily rate-limited by the provider.[/bold yellow]"
                             )
-                            if _is_free_tier_model:
-                                # Free tier → no upgrade CTA, just helpful next steps
-                                self.console.print(
-                                    "  [dim]Free models rotate through a shared capacity pool — "
-                                    "this usually clears in under a minute.[/dim]"
-                                )
-                                self.console.print(
-                                    "  [dim]You can also pick a different model with "
-                                    "[bold]/model[/bold] or press Ctrl+M.[/dim]\n"
-                                )
-                            else:
-                                if not upgrade_url:
-                                    upgrade_url = "https://utim.dev/pricing"
-                                self.console.print(
-                                    f"  [dim]Top up at [bold]{upgrade_url}[/bold] or run "
-                                    f"[bold]/balance[/bold] to check your remaining quota.[/dim]\n"
-                                )
-
-                            raise _FatalClientError(
-                                f"All models in the fallback chain are rate-limited: "
-                                f"{_rate_limit_detail}"
+                            self.console.print(
+                                "  [dim]Please wait a moment before retrying, or switch models using [bold]/model[/bold] (Ctrl+M).[/dim]\n"
                             )
+                        return {
+                            "role": "assistant",
+                            "content": rate_limit_display,
+                            "tool_calls": None,
+                        }, False
                     if attempt < model_retries:
                         delay = 3 * (attempt + 1)
                         # Interruptible wait — so Ctrl+C can abort immediately

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/orchestrator_turn_history.py

@@ -1381,7 +1381,11 @@ class TurnHistoryMixin:
                 with open("package.json", "r", encoding="utf-8") as f:
                     pkg = json.load(f)
                 if "scripts" in pkg and "test" in pkg["scripts"]:
-                    res = subprocess.run(["npm", "test"], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=60, shell=True)
+                    from shutil import which as _which_npm
+                    _npm = _which_npm("npm")
+                    if _npm is None:
+                        return "npm not found on PATH"
+                    res = subprocess.run([_npm, "test"], capture_output=True, text=True, encoding="utf-8", errors="replace", timeout=60)
                     if res.returncode != 0:
                         return _compact_test_err("npm test", res.stdout, res.stderr)
                     return None

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/plugins/hooks.py

@@ -107,11 +107,19 @@ def run_single_hook(
 
         argv = _resolve_interpreter(command, Path.cwd())
         stdin_data = json.dumps(payload)
+        # Clamp per-hook timeout: a misconfigured plugin manifest must not be
+        # able to hold the dispatch thread pool hostage (DoS guard).
+        h_timeout = min(max(float(h_timeout), 0.1), 60.0)
         if argv is None:
-            # Shell mode
-            argv = command
+            # Shell mode — run through an explicit shell argv instead of
+            # shell=True, which is injection-prone and resolves slower. On
+            # Windows, /d also skips AutoRun registry scripts (hijack guard).
+            if os.name == "nt":
+                shell_argv = ["cmd.exe", "/d", "/s", "/c", command]
+            else:
+                shell_argv = ["/bin/sh", "-c", command]
             result = subprocess.run(
-                argv, shell=True, input=stdin_data, capture_output=True,
+                shell_argv, shell=False, input=stdin_data, capture_output=True,
                 text=True, timeout=h_timeout, env=_build_env(plugin_name, event, payload),
             )
         else:

{utim_cli-2.3.19 → utim_cli-2.3.20}/utim_cli/plugins/manager.py

@@ -21,6 +21,7 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Set
 
 from utim_cli.config import get_utim_dir, config
+from utim_cli.client_utils import is_user_paid
 from utim_cli.plugins.schema import Plugin, PluginManifest
 from utim_cli.plugins.registry import get_registry_plugins, find_registry_plugin
 from utim_cli.plugins import loader as staged_loader
@@ -149,6 +150,8 @@ class PluginManager:
     # ── Enable / Disable / Toggle ────────────────────────────────────────────
 
     def enable_plugin(self, name: str) -> bool:
+        if not is_user_paid():
+            return False
         plugin = self.get_plugin(name)
         if not plugin:
             return False
@@ -171,6 +174,8 @@ class PluginManager:
         return True
 
     def toggle_plugin(self, name: str) -> bool:
+        if not is_user_paid():
+            return False
         return self.disable_plugin(name) if self.is_enabled(name) else self.enable_plugin(name)
 
     # ── Installation ─────────────────────────────────────────────────────────
@@ -191,6 +196,9 @@ class PluginManager:
     def install_plugin(self, identifier: str, force: bool = False, plugin_type: str = "auto") -> Dict[str, Any]:
         """Install a plugin from a registry name, git URL, or local path."""
         result: Dict[str, Any] = {"ok": False, "plugin": identifier, "message": ""}
+        if not is_user_paid():
+            result["message"] = "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade"
+            return result
         meta = find_registry_plugin(identifier)
         git_url = self._parse_git_url(identifier)
 
@@ -280,6 +288,12 @@ class PluginManager:
           • Any other page      -> knowledge plugin (scraped markdown becomes
              a SKILL.md the model gets injected with)
         """
+        if not is_user_paid():
+            return {
+                "ok": False,
+                "message": "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade",
+            }
+
         def _say(msg: str) -> None:
             if progress_cb:
                 progress_cb(msg)
@@ -392,6 +406,9 @@ class PluginManager:
 
         Returns (ok: bool, message: str, path: Optional[Path]).
         """
+        if not is_user_paid():
+            return False, "Plugins are only available on paid plans (Hobby plan or higher). Please upgrade your subscription at https://utim.dev/upgrade", None
+
         clean = re.sub(r"[^a-zA-Z0-9_\-]", "-", name.strip().lower()).strip("-")
         if not clean:
             return False, "Invalid plugin name", None
@@ -469,6 +486,8 @@ class PluginManager:
     # ── Aggregation (effectors) ──────────────────────────────────────────────
 
     def get_active_skills(self) -> Dict[str, Dict[str, Any]]:
+        if not is_user_paid():
+            return {}
         skills: Dict[str, Dict[str, Any]] = {}
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -480,6 +499,8 @@ class PluginManager:
         return skills
 
     def get_active_rules(self) -> List[Dict[str, Any]]:
+        if not is_user_paid():
+            return []
         rules: List[Dict[str, Any]] = []
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -487,6 +508,8 @@ class PluginManager:
         return rules
 
     def get_active_mcp_servers(self) -> Dict[str, Dict[str, Any]]:
+        if not is_user_paid():
+            return {}
         servers: Dict[str, Dict[str, Any]] = {}
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -494,6 +517,8 @@ class PluginManager:
         return servers
 
     def get_active_tools(self) -> List[Dict[str, Any]]:
+        if not is_user_paid():
+            return []
         tools: List[Dict[str, Any]] = []
         for p in self.list_plugins():
             if p.enabled and p.is_valid:
@@ -511,6 +536,8 @@ class PluginManager:
         (string/dict commands from manifests) go through hooks.py in
         parallel with per-hook timeouts.
         """
+        if not is_user_paid():
+            return []
         from utim_cli.plugins import hooks as hook_engine
         payload = payload or {}
         output: Dict[str, Any] = {}