zrb 1.21.28__py3-none-any.whl → 1.21.37__py3-none-any.whl

zrb/builtin/llm/chat_completion.py

@@ -1,7 +1,5 @@
 import os
-
-from prompt_toolkit.completion import CompleteEvent, Completer, Completion
-from prompt_toolkit.document import Document
+from typing import TYPE_CHECKING
 
 from zrb.builtin.llm.chat_session_cmd import (
     ADD_SUB_CMD,
@@ -35,240 +33,219 @@ from zrb.builtin.llm.chat_session_cmd import (
     YOLO_SET_FALSE_CMD_DESC,
     YOLO_SET_TRUE_CMD_DESC,
 )
+from zrb.util.match import fuzzy_match
+
+if TYPE_CHECKING:
+    from prompt_toolkit.completion import Completer
+
+
+def get_chat_completer() -> "Completer":
+
+    from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+    from prompt_toolkit.document import Document
 
+    class ChatCompleter(Completer):
 
-class ChatCompleter(Completer):
+        def get_completions(self, document: Document, complete_event: CompleteEvent):
+            # Slash command
+            for completion in self._complete_slash_command(document):
+                yield completion
+            for completion in self._complete_slash_file_command(document):
+                yield completion
+            # Appendix
+            for completion in self._complete_appendix(document):
+                yield completion
 
-    def get_completions(self, document: Document, complete_event: CompleteEvent):
-        # Slash command
-        for completion in self._complete_slash_command(document):
-            yield completion
-        for completion in self._complete_slash_file_command(document):
-            yield completion
-        # Appendix
-        for completion in self._complete_appendix(document):
-            yield completion
+        def _complete_slash_file_command(self, document: Document):
+            text = document.text_before_cursor
+            prefixes = []
+            for cmd in ATTACHMENT_CMD:
+                for subcmd in ADD_SUB_CMD:
+                    prefixes.append(f"{cmd} {subcmd} ")
+            for prefix in prefixes:
+                if text.startswith(prefix):
+                    pattern = text[len(prefix) :]
+                    potential_options = self._fuzzy_path_search(pattern, dirs=True)
+                    for prefixed_option in [
+                        f"{prefix}{option}" for option in potential_options
+                    ]:
+                        yield Completion(
+                            prefixed_option,
+                            start_position=-len(text),
+                        )
 
-    def _complete_slash_file_command(self, document: Document):
-        text = document.text_before_cursor
-        prefixes = []
-        for cmd in ATTACHMENT_CMD:
-            for subcmd in ADD_SUB_CMD:
-                prefixes.append(f"{cmd} {subcmd} ")
-        for prefix in prefixes:
-            if text.startswith(prefix):
-                pattern = text[len(prefix) :]
-                potential_options = self._fuzzy_path_search(pattern, dirs=False)
-                for prefixed_option in [
-                    f"{prefix}{option}" for option in potential_options
-                ]:
+        def _complete_slash_command(self, document: Document):
+            text = document.text_before_cursor
+            if not text.startswith("/"):
+                return
+            for command, description in self._get_cmd_options().items():
+                if command.lower().startswith(text.lower()):
                     yield Completion(
-                        prefixed_option,
+                        command,
                         start_position=-len(text),
+                        display_meta=description,
                     )
 
-    def _complete_slash_command(self, document: Document):
-        text = document.text_before_cursor
-        if not text.startswith("/"):
-            return
-        for command, description in self._get_cmd_options().items():
-            if command.lower().startswith(text.lower()):
+        def _complete_appendix(self, document: Document):
+            token = document.get_word_before_cursor(WORD=True)
+            prefix = "@"
+            if not token.startswith(prefix):
+                return
+            pattern = token[len(prefix) :]
+            potential_options = self._fuzzy_path_search(pattern, dirs=True)
+            for prefixed_option in [
+                f"{prefix}{option}" for option in potential_options
+            ]:
                 yield Completion(
-                    command,
-                    start_position=-len(text),
-                    display_meta=description,
+                    prefixed_option,
+                    start_position=-len(token),
                 )
 
-    def _complete_appendix(self, document: Document):
-        token = document.get_word_before_cursor(WORD=True)
-        prefix = "@"
-        if not token.startswith(prefix):
-            return
-        pattern = token[len(prefix) :]
-        potential_options = self._fuzzy_path_search(pattern, dirs=False)
-        for prefixed_option in [f"{prefix}{option}" for option in potential_options]:
-            yield Completion(
-                prefixed_option,
-                start_position=-len(token),
-            )
+        def _get_cmd_options(self):
+            cmd_options = {}
+            # Add all commands with their descriptions
+            for cmd in MULTILINE_START_CMD:
+                cmd_options[cmd] = MULTILINE_START_CMD_DESC
+            for cmd in MULTILINE_END_CMD:
+                cmd_options[cmd] = MULTILINE_END_CMD_DESC
+            for cmd in QUIT_CMD:
+                cmd_options[cmd] = QUIT_CMD_DESC
+            for cmd in WORKFLOW_CMD:
+                cmd_options[cmd] = WORKFLOW_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
+            for cmd in SAVE_CMD:
+                cmd_options[cmd] = SAVE_CMD_DESC
+            for cmd in ATTACHMENT_CMD:
+                cmd_options[cmd] = ATTACHMENT_CMD_DESC
+                for subcmd in ADD_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_ADD_SUB_CMD_DESC
+                for subcmd in CLEAR_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_CLEAR_SUB_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_SET_SUB_CMD_DESC
+            for cmd in YOLO_CMD:
+                cmd_options[cmd] = YOLO_CMD_DESC
+                for subcmd in SET_SUB_CMD:
+                    cmd_options[f"{cmd} {subcmd} true"] = YOLO_SET_TRUE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd} false"] = YOLO_SET_FALSE_CMD_DESC
+                    cmd_options[f"{cmd} {subcmd}"] = YOLO_SET_CMD_DESC
+            for cmd in HELP_CMD:
+                cmd_options[cmd] = HELP_CMD_DESC
+            for cmd in RUN_CLI_CMD:
+                cmd_options[cmd] = RUN_CLI_CMD_DESC
+            return dict(sorted(cmd_options.items()))
 
-    def _get_cmd_options(self):
-        cmd_options = {}
-        # Add all commands with their descriptions
-        for cmd in MULTILINE_START_CMD:
-            cmd_options[cmd] = MULTILINE_START_CMD_DESC
-        for cmd in MULTILINE_END_CMD:
-            cmd_options[cmd] = MULTILINE_END_CMD_DESC
-        for cmd in QUIT_CMD:
-            cmd_options[cmd] = QUIT_CMD_DESC
-        for cmd in WORKFLOW_CMD:
-            cmd_options[cmd] = WORKFLOW_CMD_DESC
-            for subcmd in ADD_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_ADD_SUB_CMD_DESC
-            for subcmd in CLEAR_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_CLEAR_SUB_CMD_DESC
-            for subcmd in SET_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = WORKFLOW_SET_SUB_CMD_DESC
-        for cmd in SAVE_CMD:
-            cmd_options[cmd] = SAVE_CMD_DESC
-        for cmd in ATTACHMENT_CMD:
-            cmd_options[cmd] = ATTACHMENT_CMD_DESC
-            for subcmd in ADD_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_ADD_SUB_CMD_DESC
-            for subcmd in CLEAR_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_CLEAR_SUB_CMD_DESC
-            for subcmd in SET_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd}"] = ATTACHMENT_SET_SUB_CMD_DESC
-        for cmd in YOLO_CMD:
-            cmd_options[cmd] = YOLO_CMD_DESC
-            for subcmd in SET_SUB_CMD:
-                cmd_options[f"{cmd} {subcmd} true"] = YOLO_SET_TRUE_CMD_DESC
-                cmd_options[f"{cmd} {subcmd} false"] = YOLO_SET_FALSE_CMD_DESC
-                cmd_options[f"{cmd} {subcmd}"] = YOLO_SET_CMD_DESC
-        for cmd in HELP_CMD:
-            cmd_options[cmd] = HELP_CMD_DESC
-        for cmd in RUN_CLI_CMD:
-            cmd_options[cmd] = RUN_CLI_CMD_DESC
-        return dict(sorted(cmd_options.items()))
+        def _fuzzy_path_search(
+            self,
+            pattern: str,
+            root: str | None = None,
+            max_results: int = 20,
+            include_hidden: bool = False,
+            case_sensitive: bool = False,
+            dirs: bool = True,
+            files: bool = True,
+        ) -> list[str]:
+            """
+            Return a list of filesystem paths under `root` that fuzzy-match `pattern`.
+            - pattern: e.g. "./some/x" or "proj util/io"
+            - include_hidden: if False skip files/dirs starting with '.'
+            - dirs/files booleans let you restrict results
+            - returns list of relative paths (from root), sorted best-first
+            """
+            root, search_pattern = self._get_root_and_search_pattern(pattern, root)
+            # specific ignore list
+            try:
+                abs_root = os.path.abspath(os.path.expanduser(root))
+                abs_cwd = os.path.abspath(os.getcwd())
+                # Check if root is a subdirectory of cwd or is cwd itself
+                is_recursive = (
+                    abs_root.startswith(abs_cwd + os.sep) or abs_root == abs_cwd
+                )
+            except Exception:
+                is_recursive = False
+            # walk filesystem
+            candidates: list[tuple[float, str]] = []
+            for dirpath, dirnames, filenames in os.walk(root):
+                # Filter directories
+                if not include_hidden:
+                    dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+                rel_dir = os.path.relpath(dirpath, root)
+                # treat '.' as empty prefix
+                if rel_dir == ".":
+                    rel_dir = ""
+                # build list of entries to test depending on files/dirs flags
+                entries = []
+                if dirs:
+                    entries.extend([os.path.join(rel_dir, d) for d in dirnames])
+                if files:
+                    entries.extend([os.path.join(rel_dir, f) for f in filenames])
+                if not is_recursive:
+                    dirnames[:] = []
+                for ent in entries:
+                    # Normalize presentation: use ./ prefix for relative paths
+                    display_path = ent if ent else "."
+                    # Skip hidden entries unless requested (double check for rel path segments)
+                    if not include_hidden:
+                        if any(
+                            seg.startswith(".")
+                            for seg in display_path.split(os.sep)
+                            if seg
+                        ):
+                            continue
+                    cand = display_path.replace(os.sep, "/")  # unify separator
+                    matched, score = fuzzy_match(cand, search_pattern)
+                    if matched:
+                        out = (
+                            cand
+                            if os.path.abspath(cand) == cand
+                            else os.path.join(root, cand)
+                        )
+                        candidates.append((score, out))
+            # sort by score then lexicographically and return top results
+            candidates.sort(key=lambda x: (x[0], x[1]))
+            return [p for _, p in candidates[:max_results]]
 
-    def _fuzzy_path_search(
-        self,
-        pattern: str,
-        root: str | None = None,
-        max_results: int = 20,
-        include_hidden: bool = False,
-        case_sensitive: bool = False,
-        dirs: bool = True,
-        files: bool = True,
-    ) -> list[str]:
-        """
-        Return a list of filesystem paths under `root` that fuzzy-match `pattern`.
-        - pattern: e.g. "./some/x" or "proj util/io"
-        - include_hidden: if False skip files/dirs starting with '.'
-        - dirs/files booleans let you restrict results
-        - returns list of relative paths (from root), sorted best-first
-        """
-        search_pattern = pattern
-        if root is None:
-            # Determine root and adjust pattern if necessary
-            expanded_pattern = os.path.expanduser(pattern)
-            if os.path.isabs(expanded_pattern) or pattern.startswith("~"):
-                # For absolute paths, find the deepest existing directory
-                if os.path.isdir(expanded_pattern):
-                    root = expanded_pattern
-                    search_pattern = ""
-                else:
+        def _get_root_and_search_pattern(
+            self,
+            pattern: str,
+            root: str | None = None,
+        ) -> tuple[str, str]:
+            search_pattern = pattern
+            if root is None:
+                # Determine root and adjust pattern if necessary
+                expanded_pattern = os.path.expanduser(pattern)
+                if os.path.isabs(expanded_pattern) or pattern.startswith("~"):
+                    # For absolute paths, find the deepest existing directory
+                    if os.path.isdir(expanded_pattern):
+                        root = expanded_pattern
+                        return (root, "")
                     root = os.path.dirname(expanded_pattern)
                     while root and not os.path.isdir(root) and len(root) > 1:
                         root = os.path.dirname(root)
                     if not os.path.isdir(root):
-                        root = "."  # Fallback
-                        search_pattern = pattern
-                    else:
-                        try:
-                            search_pattern = os.path.relpath(expanded_pattern, root)
-                            if search_pattern == ".":
-                                search_pattern = ""
-                        except ValueError:
-                            search_pattern = os.path.basename(pattern)
-            else:
-                root = "."
-                search_pattern = pattern
-        # Normalize pattern -> tokens split on path separators or whitespace
-        search_pattern = search_pattern.strip()
-        if search_pattern:
-            raw_tokens = [t for t in search_pattern.split(os.path.sep) if t]
-        else:
-            raw_tokens = []
-        # prepare tokens (case)
-        if not case_sensitive:
-            tokens = [t.lower() for t in raw_tokens]
-        else:
-            tokens = raw_tokens
-        # specific ignore list
-        try:
-            is_recursive = os.path.abspath(os.path.expanduser(root)).startswith(
-                os.path.abspath(os.getcwd())
-            )
-        except Exception:
-            is_recursive = False
-        # walk filesystem
-        candidates: list[tuple[float, str]] = []
-        for dirpath, dirnames, filenames in os.walk(root):
-            # Filter directories
-            if not include_hidden:
-                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
-            rel_dir = os.path.relpath(dirpath, root)
-            # treat '.' as empty prefix
-            if rel_dir == ".":
-                rel_dir = ""
-            # build list of entries to test depending on files/dirs flags
-            entries = []
-            if dirs:
-                entries.extend([os.path.join(rel_dir, d) for d in dirnames])
-            if files:
-                entries.extend([os.path.join(rel_dir, f) for f in filenames])
-            if not is_recursive:
-                dirnames[:] = []
-            for ent in entries:
-                # Normalize presentation: use ./ prefix for relative paths
-                display_path = ent if ent else "."
-                # Skip hidden entries unless requested (double check for rel path segments)
-                if not include_hidden:
-                    if any(
-                        seg.startswith(".") for seg in display_path.split(os.sep) if seg
-                    ):
-                        continue
-                cand = display_path.replace(os.sep, "/")  # unify separator
-                cand_cmp = cand if case_sensitive else cand.lower()
-                last_pos = 0
-                score = 0.0
-                matched_all = True
-                for token in tokens:
-                    # try contiguous substring search first
-                    idx = cand_cmp.find(token, last_pos)
-                    if idx != -1:
-                        # good match: reward contiguous early matches
-                        score += idx  # smaller idx preferred
-                        last_pos = idx + len(token)
-                    else:
-                        # fallback to subsequence matching
-                        pos = self._find_subsequence_pos(cand_cmp, token, last_pos)
-                        if pos is None:
-                            matched_all = False
-                            break
-                        # subsequence match is less preferred than contiguous substring
-                        score += pos + 0.5 * len(token)
-                        last_pos = pos + len(token)
-                if matched_all:
-                    # prefer shorter paths when score ties, so include length as tiebreaker
-                    score += 0.01 * len(cand)
-                    out = (
-                        cand
-                        if os.path.abspath(cand) == cand
-                        else os.path.join(root, cand)
-                    )
-                    candidates.append((score, out))
-        # sort by score then lexicographically and return top results
-        candidates.sort(key=lambda x: (x[0], x[1]))
-        return [p for _, p in candidates[:max_results]]
+                        return (".", pattern)  # Fallback
+                    try:
+                        search_pattern = os.path.relpath(expanded_pattern, root)
+                        if search_pattern == ".":
+                            return (root, "")
+                    except ValueError:
+                        return (root, os.path.basename(pattern))
+                # Handle redundant current directory prefixes (e.g., ./ or .\)
+                if pattern.startswith(f".{os.sep}"):
+                    return (".", pattern[len(f".{os.sep}") :])
+                if os.sep != "/" and pattern.startswith("./"):
+                    return (".", pattern[2:])
+                return (".", pattern)
+
+            if pattern.startswith(f".{os.sep}"):
+                pattern = pattern[len(f".{os.sep}") :]
+            elif os.sep != "/" and pattern.startswith("./"):
+                pattern = pattern[2:]
+            return (root, pattern)
 
-    def _find_subsequence_pos(
-        self, hay: str, needle: str, start: int = 0
-    ) -> int | None:
-        """
-        Try to locate needle in hay as a subsequence starting at `start`.
-        Returns the index of the first matched character of the subsequence or None if not match.
-        """
-        if not needle:
-            return start
-        i = start
-        j = 0
-        first_pos = None
-        while i < len(hay) and j < len(needle):
-            if hay[i] == needle[j]:
-                if first_pos is None:
-                    first_pos = i
-                j += 1
-            i += 1
-        return first_pos if j == len(needle) else None
+    return ChatCompleter()

zrb/builtin/llm/chat_session.py

@@ -101,7 +101,7 @@ async def read_user_prompt(ctx: AnyContext) -> str:
                 print_current_yolo_mode(ctx, current_yolo_mode)
                 continue
             elif is_command_match(user_input, RUN_CLI_CMD):
-                run_cli_command(ctx, user_input)
+                await run_cli_command(ctx, user_input)
                 continue
             elif is_command_match(user_input, HELP_CMD):
                 print_commands(ctx)

zrb/builtin/llm/chat_session_cmd.py

@@ -1,6 +1,7 @@
 import os
-import subprocess
+from typing import Callable
 
+from zrb.config.config import CFG
 from zrb.context.any_context import AnyContext
 from zrb.task.llm.workflow import get_available_workflows
 from zrb.util.cli.markdown import render_markdown
@@ -10,6 +11,7 @@ from zrb.util.cli.style import (
     stylize_error,
     stylize_faint,
 )
+from zrb.util.cmd.command import run_command
 from zrb.util.file import write_file
 from zrb.util.markdown import make_markdown_section
 from zrb.util.string.conversion import FALSE_STRS, TRUE_STRS, to_boolean
@@ -118,13 +120,12 @@ def save_final_result(ctx: AnyContext, user_input: str, final_result: str) -> No
     ctx.print(f"Response saved to {save_path}", plain=True)
 
 
-def run_cli_command(ctx: AnyContext, user_input: str) -> None:
+async def run_cli_command(ctx: AnyContext, user_input: str) -> None:
     command = get_command_param(user_input, RUN_CLI_CMD)
-    result = subprocess.run(
-        command,
-        shell=True,
-        capture_output=True,
-        text=True,
+    cmd_result, return_code = await run_command(
+        [CFG.DEFAULT_SHELL, "-c", command],
+        print_method=_create_faint_print(ctx),
+        timeout=3600,
     )
     ctx.print(
         render_markdown(
@@ -132,10 +133,14 @@ def run_cli_command(ctx: AnyContext, user_input: str) -> None:
                 f"`{command}`",
                 "\n".join(
                     [
-                        make_markdown_section("📤 Stdout", result.stdout, as_code=True),
-                        make_markdown_section("🚫 Stderr", result.stderr, as_code=True),
                         make_markdown_section(
-                            "🎯 Return code", f"Return Code: {result.returncode}"
+                            "📤 Stdout", cmd_result.output, as_code=True
+                        ),
+                        make_markdown_section(
+                            "🚫 Stderr", cmd_result.error, as_code=True
+                        ),
+                        make_markdown_section(
+                            "🎯 Return code", f"Return Code: {return_code}"
                         ),
                     ]
                 ),
@@ -146,8 +151,20 @@ def run_cli_command(ctx: AnyContext, user_input: str) -> None:
     ctx.print("", plain=True)
 
 
+def _create_faint_print(ctx: AnyContext) -> Callable[..., None]:
+    def print_faint(text: str):
+        ctx.print(stylize_faint(f"  {text}"), plain=True)
+
+    return print_faint
+
+
 def get_new_yolo_mode(old_yolo_mode: str | bool, user_input: str) -> str | bool:
-    new_yolo_mode = get_command_param(user_input, YOLO_CMD)
+    if not is_command_match(user_input, YOLO_CMD):
+        return old_yolo_mode
+    if is_command_match(user_input, YOLO_CMD, SET_SUB_CMD):
+        new_yolo_mode = get_command_param(user_input, YOLO_CMD, SET_SUB_CMD)
+    else:
+        new_yolo_mode = get_command_param(user_input, YOLO_CMD)
     if new_yolo_mode != "":
         if new_yolo_mode in TRUE_STRS or new_yolo_mode in FALSE_STRS:
             return to_boolean(new_yolo_mode)

zrb/builtin/llm/chat_trigger.py

@@ -3,6 +3,7 @@ import os
 from asyncio import StreamReader
 from typing import TYPE_CHECKING, Any, Callable, Coroutine
 
+from zrb.builtin.llm.chat_completion import get_chat_completer
 from zrb.context.any_context import AnyContext
 from zrb.util.run import run_async
 
@@ -57,13 +58,11 @@ class LLMChatTrigger:
         """Reads one line of input using the provided reader."""
         from prompt_toolkit import PromptSession
 
-        from zrb.builtin.llm.chat_completion import ChatCompleter
-
         try:
             if isinstance(reader, PromptSession):
-                bottom_toolbar = f"📁 Current directory: {os.getcwd()}"
+                bottom_toolbar = f"📌 Current directory: {os.getcwd()}"
                 return await reader.prompt_async(
-                    completer=ChatCompleter(), bottom_toolbar=bottom_toolbar
+                    completer=get_chat_completer(), bottom_toolbar=bottom_toolbar
                 )
             line_bytes = await reader.readline()
             if not line_bytes:

zrb/builtin/llm/tool/cli.py

@@ -1,5 +1,11 @@
-import subprocess
+import asyncio
 import sys
+from typing import Callable
+
+from zrb.config.config import CFG
+from zrb.context.any_context import AnyContext
+from zrb.util.cli.style import stylize_faint
+from zrb.util.cmd.command import run_command
 
 if sys.version_info >= (3, 12):
     from typing import TypedDict
@@ -15,38 +21,63 @@ class ShellCommandResult(TypedDict):
         return_code: The return code, 0 indicating no error
         stdout: Standard output
         stderr: Standard error
+        display: Combination of standard output and standard error, interlaced
     """
 
     return_code: int
     stdout: str
     stderr: str
+    display: str
 
 
-def run_shell_command(command: str) -> ShellCommandResult:
+async def run_shell_command(
+    ctx: AnyContext, command: str, timeout: int = 30
+) -> ShellCommandResult:
     """
     Executes a non-interactive shell command on the user's machine.
 
+    **EFFICIENCY TIP:**
+    Combine multiple shell commands into a single call using `&&` or `;` to save steps.
+    Example: `mkdir new_dir && cd new_dir && touch file.txt`
+
     CRITICAL: This tool runs with user-level permissions. Explain commands that modify
         the system (e.g., `git`, `pip`) and ask for confirmation.
     IMPORTANT: Long-running processes should be run in the background (e.g., `command &`).
 
     Example:
-    run_shell_command(command='ls -l')
+    run_shell_command(command='ls -l', timeout=30)
 
     Args:
         command (str): The exact shell command to be executed.
+        timeout (int): The maximum time in seconds to wait for the command to finish.
+            Defaults to 30.
 
     Returns:
         dict: return_code, stdout, and stderr.
     """
-    result = subprocess.run(
-        command,
-        shell=True,
-        capture_output=True,
-        text=True,
-    )
-    return {
-        "return_code": result.returncode,
-        "stdout": result.stdout,
-        "stderr": result.stderr,
-    }
+    try:
+        cmd_result, return_code = await run_command(
+            [CFG.DEFAULT_SHELL, "-c", command],
+            print_method=_create_faint_print(ctx),
+            timeout=timeout,
+        )
+        return {
+            "return_code": return_code,
+            "stdout": cmd_result.output,
+            "stderr": cmd_result.error,
+            "display": cmd_result.display,
+        }
+    except asyncio.TimeoutError:
+        return {
+            "return_code": 124,
+            "stdout": "",
+            "stderr": f"Command timeout after {timeout} seconds",
+            "display": f"Command timeout after {timeout} seconds",
+        }
+
+
+def _create_faint_print(ctx: AnyContext) -> Callable[..., None]:
+    def print_faint(text: str):
+        ctx.print(stylize_faint(f"  {text}"), plain=True)
+
+    return print_faint